derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
26107 lines
1.4 MiB
Plaintext
26107 lines
1.4 MiB
Plaintext
/* ************************************************************************
|
|
* Copyright (C) 2016-2025 Advanced Micro Devices, Inc. All rights reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
* ************************************************************************ */
|
|
|
|
//! HIP = Heterogeneous-compute Interface for Portability
|
|
//!
|
|
//! Define a extremely thin runtime layer that allows source code to be compiled unmodified
|
|
//! through either AMD HCC or NVCC. Key features tend to be in the spirit
|
|
//! and terminology of CUDA, but with a portable path to other accelerators as well.
|
|
//!
|
|
//! This is the master include file for hipblas, wrapping around rocblas and cublas "version 2"
|
|
|
|
#ifndef HIPBLAS_H
|
|
#define HIPBLAS_H
|
|
|
|
#include "hipblas-export.h"
|
|
#include "hipblas-version.h"
|
|
#include <hip/hip_complex.h>
|
|
#include <hip/hip_runtime_api.h>
|
|
#include <hip/library_types.h>
|
|
#include <hipblas-common/hipblas-common.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
#ifdef __HIP_PLATFORM_NVCC__
|
|
#include <cublas_v2.h>
|
|
#endif
|
|
|
|
/* Workaround clang bug:
|
|
|
|
This macro expands to static if clang is used; otherwise it expands empty.
|
|
It is intended to be used in variable template specializations, where clang
|
|
requires static in order for the specializations to have internal linkage,
|
|
while technically, storage class specifiers besides thread_local are not
|
|
allowed in template specializations, and static in the primary template
|
|
definition should imply internal linkage for all specializations.
|
|
|
|
If clang shows an error for improperly using a storage class specifier in
|
|
a specialization, then HIPBLAS_CLANG_STATIC should be redefined as empty,
|
|
and perhaps removed entirely, if the above bug has been fixed.
|
|
*/
|
|
#if __clang__
|
|
#define HIPBLAS_CLANG_STATIC static
|
|
#else
|
|
#define HIPBLAS_CLANG_STATIC
|
|
#endif
|
|
|
|
#ifndef HIPBLAS_NO_DEPRECATED_WARNINGS
|
|
#ifndef HIPBLAS_DEPRECATED_MSG
|
|
#ifndef _MSC_VER
|
|
#define HIPBLAS_DEPRECATED_MSG(MSG) //__attribute__((deprecated(#MSG)))
|
|
#else
|
|
#define HIPBLAS_DEPRECATED_MSG(MSG) //__declspec(deprecated(#MSG))
|
|
#endif
|
|
#endif
|
|
#else
|
|
#ifndef HIPBLAS_DEPRECATED_MSG
|
|
#define HIPBLAS_DEPRECATED_MSG(MSG)
|
|
#endif
|
|
#endif
|
|
|
|
/*
|
|
* Naming conventions and Notations:
|
|
*
|
|
* 1. Please follow the naming convention
|
|
* Big case for matrix, e.g. matrix A, B, C GEMM (C = A*B)
|
|
* Lower case for vector, e.g. vector x, y GEMV (y = A*x)
|
|
*
|
|
* 2. Specify the supported precisions for both rocBLAS and cuBLAS backend for any new functions:
|
|
* For eg:
|
|
* - Supported precisions in rocBLAS : h,bf,s,d,c,z
|
|
* - Supported precisions in cuBLAS : s,d,c,z
|
|
* Use the following notations,
|
|
* h = half
|
|
* bf = 16 bit brian floating point
|
|
* s = single
|
|
* d = double
|
|
* c = single complex
|
|
* z = double complex
|
|
*/
|
|
|
|
/*! \brief ``hipblasHandle_t`` is a void pointer that stores the library context (either rocBLAS or cuBLAS).*/
|
|
typedef void* hipblasHandle_t;
|
|
|
|
/*! \brief To specify the datatype as an unsigned short */
|
|
|
|
#if __cplusplus < 201103L || !defined(HIPBLAS_USE_HIP_HALF)
|
|
|
|
typedef uint16_t hipblasHalf;
|
|
|
|
#else
|
|
|
|
#include <hip/hip_fp16.h>
|
|
typedef __half hipblasHalf;
|
|
|
|
#endif
|
|
|
|
/*! \brief To specify the datatype as a signed char */
|
|
typedef int8_t hipblasInt8;
|
|
|
|
/*! \brief Stride between matrices or vectors in strided_batched functions.*/
|
|
typedef int64_t hipblasStride;
|
|
|
|
/*! \brief Struct to represent a 16-bit Brain floating-point number.*/
|
|
#if defined(HIPBLAS_USE_HIP_BFLOAT16)
|
|
|
|
// note that hip_bfloat16 isn't currently supported with cuda backend
|
|
#include <hip/hip_bfloat16.h>
|
|
typedef hip_bfloat16 hipblasBfloat16;
|
|
|
|
#elif __cplusplus < 201103L || !defined(HIPBLAS_BFLOAT16_CLASS)
|
|
|
|
// If this is a C or C++ compiler below C++11, or not requesting HIPBLAS_BFLOAT16_CLASS,
|
|
// we only include a minimal definition of hipblasBfloat16
|
|
typedef struct hipblasBfloat16
|
|
{
|
|
uint16_t data;
|
|
} hipblasBfloat16;
|
|
|
|
#else
|
|
|
|
class hipblasBfloat16
|
|
{
|
|
public:
|
|
uint16_t data;
|
|
|
|
// zero extend lower 16 bits of bfloat16 to convert to IEEE float
|
|
static float bfloat16_to_float(hipblasBfloat16 val)
|
|
{
|
|
union
|
|
{
|
|
uint32_t int32;
|
|
float fp32;
|
|
} u = {uint32_t(val.data) << 16};
|
|
return u.fp32;
|
|
}
|
|
|
|
static hipblasBfloat16 float_to_bfloat16(float f)
|
|
{
|
|
hipblasBfloat16 rv;
|
|
union
|
|
{
|
|
float fp32;
|
|
uint32_t int32;
|
|
} u = {f};
|
|
if(~u.int32 & 0x7f800000)
|
|
{
|
|
u.int32 += 0x7fff + ((u.int32 >> 16) & 1); // Round to nearest, round to even
|
|
}
|
|
else if(u.int32 & 0xffff)
|
|
{
|
|
u.int32 |= 0x10000; // Preserve signaling NaN
|
|
}
|
|
rv.data = uint16_t(u.int32 >> 16);
|
|
return rv;
|
|
}
|
|
|
|
hipblasBfloat16() = default;
|
|
|
|
// round upper 16 bits of IEEE float to convert to bfloat16
|
|
explicit hipblasBfloat16(float f)
|
|
: data(float_to_bfloat16(f))
|
|
{
|
|
}
|
|
|
|
// zero extend lower 16 bits of bfloat16 to convert to IEEE float
|
|
operator float() const
|
|
{
|
|
union
|
|
{
|
|
uint32_t int32;
|
|
float fp32;
|
|
} u = {uint32_t(data) << 16};
|
|
return u.fp32;
|
|
}
|
|
|
|
explicit operator bool() const
|
|
{
|
|
return data & 0x7fff;
|
|
}
|
|
|
|
inline hipblasBfloat16& operator+=(const hipblasBfloat16& a)
|
|
{
|
|
*this = hipblasBfloat16(float(*this) + float(a));
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
typedef struct
|
|
{
|
|
uint16_t data;
|
|
} hipblasBfloat16_public;
|
|
|
|
static_assert(std::is_standard_layout<hipblasBfloat16>{},
|
|
"hipblasBfloat16 is not a standard layout type, and thus is "
|
|
"incompatible with C.");
|
|
|
|
static_assert(std::is_trivial<hipblasBfloat16>{},
|
|
"hipblasBfloat16 is not a trivial type, and thus is "
|
|
"incompatible with C.");
|
|
|
|
static_assert(sizeof(hipblasBfloat16) == sizeof(hipblasBfloat16_public)
|
|
&& offsetof(hipblasBfloat16, data) == offsetof(hipblasBfloat16_public, data),
|
|
"internal hipblasBfloat16 does not match public hipblasBfloat16_public");
|
|
|
|
#endif
|
|
|
|
/*! \brief Indicates whether scalar pointers are on the host or device. This is used for scalars alpha and beta and for scalar function return values. */
|
|
typedef enum
|
|
{
|
|
HIPBLAS_POINTER_MODE_HOST, /**< Scalar values affected by this variable will be located on the host. */
|
|
HIPBLAS_POINTER_MODE_DEVICE /**< Scalar values affected by this variable will be located on the device. */
|
|
} hipblasPointerMode_t;
|
|
|
|
#ifndef HIPBLAS_FILL_MODE_DECLARED
|
|
#define HIPBLAS_FILL_MODE_DECLARED
|
|
/*! \brief Used by the Hermitian, symmetric, and triangular matrix routines to specify whether the upper or lower triangle is being referenced. */
|
|
typedef enum
|
|
{
|
|
HIPBLAS_FILL_MODE_UPPER = 121, /**< Upper triangle. */
|
|
HIPBLAS_FILL_MODE_LOWER = 122, /**< Lower triangle. */
|
|
HIPBLAS_FILL_MODE_FULL = 123
|
|
} hipblasFillMode_t;
|
|
|
|
#elif __cplusplus >= 201103L
|
|
static_assert(HIPBLAS_FILL_MODE_UPPER == 121,
|
|
"Inconsistent declaration of HIPBLAS_FILL_MODE_UPPER");
|
|
static_assert(HIPBLAS_FILL_MODE_LOWER == 122,
|
|
"Inconsistent declaration of HIPBLAS_FILL_MODE_LOWER");
|
|
static_assert(HIPBLAS_FILL_MODE_FULL == 123, "Inconsistent declaration of HIPBLAS_FILL_MODE_FULL");
|
|
#endif // HIPBLAS_FILL_MODE_DECLARED
|
|
|
|
#ifndef HIPBLAS_DIAG_TYPE_DECLARED
|
|
#define HIPBLAS_DIAG_TYPE_DECLARED
|
|
/*! \brief Used by the triangular matrix routines to specify whether the matrix is unit triangular.*/
|
|
typedef enum
|
|
{
|
|
HIPBLAS_DIAG_NON_UNIT = 131, /**< Non-unit triangular. */
|
|
HIPBLAS_DIAG_UNIT = 132 /**< Unit triangular. */
|
|
} hipblasDiagType_t;
|
|
|
|
#elif __cplusplus >= 201103L
|
|
static_assert(HIPBLAS_DIAG_NON_UNIT == 131, "Inconsistent declaration of HIPBLAS_DIAG_NON_UNIT");
|
|
static_assert(HIPBLAS_DIAG_UNIT == 132, "Inconsistent declaration of HIPBLAS_DIAG_UNIT");
|
|
#endif // HIPBLAS_DIAG_TYPE_DECLARED
|
|
|
|
#ifndef HIPBLAS_SIDE_MODE_DECLARED
|
|
#define HIPBLAS_SIDE_MODE_DECLARED
|
|
/*! \brief Indicates the side matrix A is located on, relative to matrix B, during multiplication. */
|
|
typedef enum
|
|
{
|
|
HIPBLAS_SIDE_LEFT
|
|
= 141, /**< Multiply general matrix by symmetric, Hermitian, or triangular matrix on the left. */
|
|
HIPBLAS_SIDE_RIGHT
|
|
= 142, /**< Multiply general matrix by symmetric, Hermitian, or triangular matrix on the right. */
|
|
HIPBLAS_SIDE_BOTH = 143
|
|
} hipblasSideMode_t;
|
|
#elif __cplusplus >= 201103L
|
|
static_assert(HIPBLAS_SIDE_LEFT == 141, "Inconsistent declaration of HIPBLAS_SIDE_LEFT");
|
|
static_assert(HIPBLAS_SIDE_RIGHT == 142, "Inconsistent declaration of HIPBLAS_SIDE_RIGHT");
|
|
static_assert(HIPBLAS_SIDE_BOTH == 143, "Inconsistent declaration of HIPBLAS_SIDE_BOTH");
|
|
#endif // HIPBLAS_SIDE_MODE_DECLARED
|
|
|
|
typedef enum
|
|
{
|
|
HIPBLAS_DEFAULT_MATH,
|
|
HIPBLAS_XF32_XDL_MATH, /* equivalent to rocblas_xf32_xdl_math_op, not supported in cuBLAS */
|
|
HIPBLAS_PEDANTIC_MATH, /* equivalent to CUBLAS_PEDANTIC_MATH, not yet supported in rocBLAS */
|
|
HIPBLAS_TF32_TENSOR_OP_MATH, /* use TF32 tensor cores with cuBLAS backend, not supported in rocBLAS */
|
|
HIPBLAS_MATH_DISALLOW_REDUCED_PRECISION_REDUCTION, /* see cuBLAS documentation, not supported in rocBLAS */
|
|
HIPBLAS_TENSOR_OP_MATH /* DEPRECATED, use Tensor Core operations with cuBLAS backend */
|
|
} hipblasMath_t;
|
|
|
|
/*! \brief Indicates whether the layer is active through the use of a bitmask. */
|
|
typedef enum
|
|
{
|
|
HIPBLAS_GEMM_DEFAULT = 160 /**< enumerator ``rocblas_gemm_algo_standard`` */
|
|
} hipblasGemmAlgo_t;
|
|
|
|
/*! \brief Indicates whether atomics operations are allowed. Not allowing atomic operations can generally improve determinism and repeatability of results at a cost of performance.
|
|
* By default, the rocBLAS backend allows atomic operations, while the cuBLAS backend disallows atomic operations. See the backend documentation
|
|
* for more details. */
|
|
typedef enum
|
|
{
|
|
HIPBLAS_ATOMICS_NOT_ALLOWED = 0, /**< Algorithms will refrain from atomics where applicable. */
|
|
HIPBLAS_ATOMICS_ALLOWED = 1 /**< Algorithms will take advantage of atomics where applicable. */
|
|
} hipblasAtomicsMode_t;
|
|
|
|
/*! \brief Control flags passed into gemm ex with flags algorithms. Only relevant with rocBLAS backend. See rocBLAS documentation
|
|
* for more information.*/
|
|
typedef enum
|
|
{
|
|
HIPBLAS_GEMM_FLAGS_NONE = 0x0, /**< Default empty flags */
|
|
HIPBLAS_GEMM_FLAGS_USE_CU_EFFICIENCY
|
|
= 0x2, /**< enumerator rocblas_gemm_flags_use_cu_efficiency */
|
|
HIPBLAS_GEMM_FLAGS_FP16_ALT_IMPL = 0x4, /**< enumerator rocblas_gemm_flags_fp16_alt_impl */
|
|
HIPBLAS_GEMM_FLAGS_CHECK_SOLUTION_INDEX
|
|
= 0x8, /**< enumerator rocblas_gemm_flags_check_solution_index */
|
|
HIPBLAS_GEMM_FLAGS_FP16_ALT_IMPL_RNZ
|
|
= 0x10 /**< enumerator rocblas_gemm_flags_fp16_alt_impl_rnz */
|
|
} hipblasGemmFlags_t;
|
|
|
|
/*! \brief Library property types for querying version components. */
|
|
typedef enum
|
|
{
|
|
HIPBLAS_MAJOR_VERSION = 0, /**< Major version number */
|
|
HIPBLAS_MINOR_VERSION = 1, /**< Minor version number */
|
|
HIPBLAS_PATCH_LEVEL = 2 /**< Patch level */
|
|
} hipblasLibraryProperty_t;
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*! \brief Create the hipBLAS handle. */
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCreate(hipblasHandle_t* handle);
|
|
|
|
/*! \brief Destroys the library context created using hipblasCreate(). */
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDestroy(hipblasHandle_t handle);
|
|
|
|
/*! \brief Gets the hipBLAS library version number.
|
|
\details
|
|
Returns version as integer: major * 10000 + minor * 100 + patch.
|
|
Example: version 3.5.1 returns 30501.
|
|
|
|
Handle parameter can be NULL.
|
|
|
|
@param[in] handle Handle to library context (can be NULL)
|
|
@param[out] version Pointer to integer for version number
|
|
|
|
@return HIPBLAS_STATUS_SUCCESS or HIPBLAS_STATUS_INVALID_VALUE if version is NULL
|
|
*/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGetVersion(hipblasHandle_t handle, int* version);
|
|
|
|
/*! \brief Gets a specific property of the hipBLAS library.
|
|
\details
|
|
Returns requested property value (major, minor, or patch).
|
|
Does not require a handle.
|
|
|
|
@param[in] type Property type to query
|
|
@param[out] value Pointer to integer for property value
|
|
|
|
@return HIPBLAS_STATUS_SUCCESS or HIPBLAS_STATUS_INVALID_VALUE
|
|
*/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGetProperty(hipblasLibraryProperty_t type, int* value);
|
|
|
|
/*! \brief Sets the stream for the handle */
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSetStream(hipblasHandle_t handle, hipStream_t streamId);
|
|
|
|
/*! \brief Gets stream[0] for the handle */
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGetStream(hipblasHandle_t handle, hipStream_t* streamId);
|
|
|
|
/*! \brief Sets hipBLAS pointer mode */
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSetPointerMode(hipblasHandle_t handle,
|
|
hipblasPointerMode_t mode);
|
|
/*! \brief Gets hipBLAS pointer mode */
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGetPointerMode(hipblasHandle_t handle,
|
|
hipblasPointerMode_t* mode);
|
|
|
|
/*! \brief Set hipblas math mode */
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSetMathMode(hipblasHandle_t handle, hipblasMath_t mode);
|
|
|
|
/*! \brief Get hipblas math mode */
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGetMathMode(hipblasHandle_t handle, hipblasMath_t* mode);
|
|
|
|
/*! \brief Set hipblas workspace to user-owned device buffer */
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSetWorkspace(hipblasHandle_t handle,
|
|
void* workspace,
|
|
size_t workspaceSizeInBytes);
|
|
|
|
/*! \brief Copy vector from host to device.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in the vector.
|
|
@param[in]
|
|
elemSize [int]
|
|
Size of both vectors in bytes.
|
|
@param[in]
|
|
x pointer to vector on the host.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of the vector.
|
|
@param[out]
|
|
y pointer to vector on the device.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of the vector.
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasSetVector(int n, int elemSize, const void* x, int incx, void* y, int incy);
|
|
|
|
/*! \brief Copy vector from device to host.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in the vector.
|
|
@param[in]
|
|
elemSize [int]
|
|
Size of both vectors in bytes.
|
|
@param[in]
|
|
x pointer to vector on the device.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of the vector.
|
|
@param[out]
|
|
y pointer to vector on the host.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of the vector.
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasGetVector(int n, int elemSize, const void* x, int incx, void* y, int incy);
|
|
|
|
/*! \brief Copy matrix from host to device.
|
|
@param[in]
|
|
rows [int]
|
|
number of rows in the matrix.
|
|
@param[in]
|
|
cols [int]
|
|
number of columns in the matrix.
|
|
@param[in]
|
|
elemSize [int]
|
|
number of bytes per element in the matrix.
|
|
@param[in]
|
|
AP pointer to matrix on the host.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A. lda >= rows.
|
|
@param[out]
|
|
BP pointer to matrix on the GPU.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of B. ldb >= rows.
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasSetMatrix(int rows, int cols, int elemSize, const void* AP, int lda, void* BP, int ldb);
|
|
|
|
/*! \brief Copy matrix from device to host.
|
|
@param[in]
|
|
rows [int]
|
|
number of rows in the matrix.
|
|
@param[in]
|
|
cols [int]
|
|
number of columns in the matrix.
|
|
@param[in]
|
|
elemSize [int]
|
|
number of bytes per element in the matrix.
|
|
@param[in]
|
|
AP pointer to matrix on the GPU.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A. lda >= rows.
|
|
@param[out]
|
|
BP pointer to matrix on the host.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of B. ldb >= rows.
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasGetMatrix(int rows, int cols, int elemSize, const void* AP, int lda, void* BP, int ldb);
|
|
|
|
/*! \brief Asynchronously copy vector from host to device.
|
|
\details
|
|
``hipblasSetVectorAsync`` copies a vector from pinned host memory to device memory asynchronously.
|
|
Memory on the host must be allocated with ``hipHostMalloc`` or the transfer will be synchronous.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in the vector.
|
|
@param[in]
|
|
elemSize [int]
|
|
number of bytes per element in the matrix.
|
|
@param[in]
|
|
x pointer to vector on the host.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of the vector.
|
|
@param[out]
|
|
y pointer to vector on the device.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of the vector.
|
|
@param[in]
|
|
stream specifies the stream into which this transfer request is queued.
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSetVectorAsync(
|
|
int n, int elemSize, const void* x, int incx, void* y, int incy, hipStream_t stream);
|
|
|
|
/*! \brief Asynchronously copy vector from device to host.
|
|
\details
|
|
``hipblasGetVectorAsync`` copies a vector from pinned host memory to device memory asynchronously.
|
|
Memory on the host must be allocated with ``hipHostMalloc`` or the transfer will be synchronous.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in the vector.
|
|
@param[in]
|
|
elemSize [int]
|
|
number of bytes per element in the matrix.
|
|
@param[in]
|
|
x pointer to vector on the device.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of the vector.
|
|
@param[out]
|
|
y pointer to vector on the host.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of the vector.
|
|
@param[in]
|
|
stream specifies the stream into which this transfer request is queued.
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGetVectorAsync(
|
|
int n, int elemSize, const void* x, int incx, void* y, int incy, hipStream_t stream);
|
|
|
|
/*! \brief Asynchronously copy matrix from host to device.
|
|
\details
|
|
``hipblasSetMatrixAsync`` copies a matrix from pinned host memory to device memory asynchronously.
|
|
Memory on the host must be allocated with ``hipHostMalloc`` or the transfer will be synchronous.
|
|
@param[in]
|
|
rows [int]
|
|
number of rows in matrices.
|
|
@param[in]
|
|
cols [int]
|
|
number of columns in matrices.
|
|
@param[in]
|
|
elemSize [int]
|
|
number of bytes per element in the matrix.
|
|
@param[in]
|
|
AP pointer to matrix on the host.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A. lda >= rows.
|
|
@param[out]
|
|
BP pointer to matrix on the GPU.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of B. ldb >= rows.
|
|
@param[in]
|
|
stream specifies the stream into which this transfer request is queued.
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSetMatrixAsync(int rows,
|
|
int cols,
|
|
int elemSize,
|
|
const void* AP,
|
|
int lda,
|
|
void* BP,
|
|
int ldb,
|
|
hipStream_t stream);
|
|
/*! \brief Asynchronously copy matrix from device to host.
|
|
\details
|
|
``hipblasGetMatrixAsync`` copies a matrix from device memory to pinned host memory asynchronously.
|
|
Memory on the host must be allocated with ``hipHostMalloc`` or the transfer will be synchronous.
|
|
@param[in]
|
|
rows [int]
|
|
number of rows in matrices.
|
|
@param[in]
|
|
cols [int]
|
|
number of columns in matrices.
|
|
@param[in]
|
|
elemSize [int]
|
|
number of bytes per element in the matrix.
|
|
@param[in]
|
|
AP pointer to matrix on the GPU.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A. lda >= rows.
|
|
@param[out]
|
|
BP pointer to matrix on the host.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of B. ldb >= rows.
|
|
@param[in]
|
|
stream specifies the stream into which this transfer request is queued.
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGetMatrixAsync(int rows,
|
|
int cols,
|
|
int elemSize,
|
|
const void* AP,
|
|
int lda,
|
|
void* BP,
|
|
int ldb,
|
|
hipStream_t stream);
|
|
|
|
/*! \brief Sets hipblasSetAtomicsMode*/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSetAtomicsMode(hipblasHandle_t handle,
|
|
hipblasAtomicsMode_t atomics_mode);
|
|
|
|
/*! \brief Gets hipblasSetAtomicsMode*/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGetAtomicsMode(hipblasHandle_t handle,
|
|
hipblasAtomicsMode_t* atomics_mode);
|
|
|
|
/*! \brief Set alpha stride for a limited set of batched and strided_batched functions to specify the stride for alpha between successive batch elements.
|
|
Only applies to hipblasPointerModeDevice and thus device side allocations.
|
|
It enables interpretation of the alpha pointer for both batched and strided_batched functions as a pointer to a vector of values.
|
|
Default value is 0 which treats it as a pointer to a single scalar. Support is denoted with specific function documentation.
|
|
Warning this is a modal like state in the handle. Restore to value 0 if no longer applicable to later function calls.
|
|
- Supported in rocBLAS backend only.
|
|
*/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSetBatchAlphaStride(hipblasHandle_t handle,
|
|
hipblasStride alpha_stride);
|
|
|
|
/*! \brief Get batch alpha stride from the handle. */
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGetBatchAlphaStride(hipblasHandle_t handle,
|
|
hipblasStride* alpha_stride);
|
|
|
|
/*! \brief Set beta stride for a limited set of batched and strided_batched functions to specify the stride for beta between successive batch elements.
|
|
Only applies to hipblasPointerModeDevice and thus device side allocations.
|
|
It enables interpretation of the beta pointer for both batched and strided_batched functions as a pointer to a vector of values.
|
|
Default value is 0 which treats it as a pointer to a single scalar. Support is denoted with specific function documentation.
|
|
Warning this is a modal like state in the handle. Restore to value 0 if no longer applicable to later function calls.
|
|
- Supported in rocBLAS backend only.
|
|
*/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSetBatchBetaStride(hipblasHandle_t handle,
|
|
hipblasStride beta_stride);
|
|
|
|
/*! \brief Get batch beta stride from the handle. */
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGetBatchBetaStride(hipblasHandle_t handle,
|
|
hipblasStride* beta_stride);
|
|
|
|
/*
|
|
* ===========================================================================
|
|
* level 1 BLAS
|
|
* ===========================================================================
|
|
*/
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The amax functions find the first index of the element of maximum magnitude of a vector ``x``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of y.
|
|
@param[inout]
|
|
result
|
|
device pointer or host pointer to store the amax index.
|
|
Return value is 0.0 if n, incx<=0.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasIsamax(hipblasHandle_t handle, int n, const float* x, int incx, int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasIdamax(hipblasHandle_t handle, int n, const double* x, int incx, int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasIcamax(hipblasHandle_t handle, int n, const hipComplex* x, int incx, int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasIzamax(hipblasHandle_t handle, int n, const hipDoubleComplex* x, int incx, int* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIsamax_64(
|
|
hipblasHandle_t handle, int64_t n, const float* x, int64_t incx, int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIdamax_64(
|
|
hipblasHandle_t handle, int64_t n, const double* x, int64_t incx, int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIcamax_64(
|
|
hipblasHandle_t handle, int64_t n, const hipComplex* x, int64_t incx, int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIzamax_64(
|
|
hipblasHandle_t handle, int64_t n, const hipDoubleComplex* x, int64_t incx, int64_t* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The amaxBatched functions find the first index of the element of maximum magnitude of each vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each vector x_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i. incx must be > 0.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch. Must be > 0.
|
|
@param[out]
|
|
result
|
|
device or host array of pointers of batchCount size for results.
|
|
Return value is 0 if n, incx<=0.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIsamaxBatched(
|
|
hipblasHandle_t handle, int n, const float* const x[], int incx, int batchCount, int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIdamaxBatched(
|
|
hipblasHandle_t handle, int n, const double* const x[], int incx, int batchCount, int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIcamaxBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIzamaxBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIsamaxBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIdamaxBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIcamaxBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIzamaxBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The amaxStridedBatched functions find the first index of the element of maximum magnitude of each vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each vector x_i.
|
|
@param[in]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i. incx must be > 0.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
specifies the pointer increment between one x_i and the next x_(i + 1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[out]
|
|
result
|
|
device or host pointer for storing contiguous batchCount results.
|
|
Return value is 0 if n <= 0, incx<=0.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIsamaxStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIdamaxStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIcamaxStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIzamaxStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIsamaxStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIdamaxStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIcamaxStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIzamaxStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The amin functions find the first index of the element of minimum magnitude of a vector ``x``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of y.
|
|
@param[inout]
|
|
result
|
|
device pointer or host pointer to store the amin index.
|
|
Return value is 0.0 if n, incx<=0.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasIsamin(hipblasHandle_t handle, int n, const float* x, int incx, int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasIdamin(hipblasHandle_t handle, int n, const double* x, int incx, int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasIcamin(hipblasHandle_t handle, int n, const hipComplex* x, int incx, int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasIzamin(hipblasHandle_t handle, int n, const hipDoubleComplex* x, int incx, int* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIsamin_64(
|
|
hipblasHandle_t handle, int64_t n, const float* x, int64_t incx, int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIdamin_64(
|
|
hipblasHandle_t handle, int64_t n, const double* x, int64_t incx, int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIcamin_64(
|
|
hipblasHandle_t handle, int64_t n, const hipComplex* x, int64_t incx, int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIzamin_64(
|
|
hipblasHandle_t handle, int64_t n, const hipDoubleComplex* x, int64_t incx, int64_t* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The aminBatched functions find the first index of the element of minimum magnitude of each vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each vector x_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i. incx must be > 0.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch. Must be > 0.
|
|
@param[out]
|
|
result
|
|
device or host pointers to array of batchCount size for results.
|
|
Return value is 0 if n, incx<=0.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIsaminBatched(
|
|
hipblasHandle_t handle, int n, const float* const x[], int incx, int batchCount, int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIdaminBatched(
|
|
hipblasHandle_t handle, int n, const double* const x[], int incx, int batchCount, int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIcaminBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIzaminBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIsaminBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIdaminBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIcaminBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIzaminBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The aminStridedBatched functions find the first index of the element of minimum magnitude of each vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each vector x_i.
|
|
@param[in]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i. incx must be > 0.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
specifies the pointer increment between one x_i and the next x_(i + 1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[out]
|
|
result
|
|
device or host pointer to array for storing contiguous batchCount results.
|
|
Return value is 0 if n <= 0, incx<=0.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIsaminStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIdaminStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIcaminStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIzaminStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
int* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIsaminStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIdaminStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIcaminStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasIzaminStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
int64_t* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The asum functions compute the sum of the magnitudes of elements of a real vector ``x``,
|
|
or the sum of the magnitudes of the real and imaginary parts of elements if ``x`` is a complex vector.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x and y.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x. incx must be > 0.
|
|
@param[inout]
|
|
result
|
|
device pointer or host pointer to store the asum product.
|
|
Return value is 0.0 if n <= 0.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasSasum(hipblasHandle_t handle, int n, const float* x, int incx, float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasDasum(hipblasHandle_t handle, int n, const double* x, int incx, double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasScasum(hipblasHandle_t handle, int n, const hipComplex* x, int incx, float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDzasum(
|
|
hipblasHandle_t handle, int n, const hipDoubleComplex* x, int incx, double* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasSasum_64(hipblasHandle_t handle, int64_t n, const float* x, int64_t incx, float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDasum_64(
|
|
hipblasHandle_t handle, int64_t n, const double* x, int64_t incx, double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScasum_64(
|
|
hipblasHandle_t handle, int64_t n, const hipComplex* x, int64_t incx, float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDzasum_64(
|
|
hipblasHandle_t handle, int64_t n, const hipDoubleComplex* x, int64_t incx, double* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The asumBatched functions computes the sum of the magnitudes of the elements in a batch of real vectors ``x_i``,
|
|
or the sum of the magnitudes of the real and imaginary parts of elements if ``x_i`` is a complex
|
|
vector, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each vector x_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i. incx must be > 0.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[out]
|
|
result
|
|
device array or host array of batchCount size for results.
|
|
Return value is 0.0 if n, incx<=0.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSasumBatched(
|
|
hipblasHandle_t handle, int n, const float* const x[], int incx, int batchCount, float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDasumBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* const x[],
|
|
int incx,
|
|
int batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScasumBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
int batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDzasumBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount,
|
|
double* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSasumBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDasumBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScasumBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDzasumBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
double* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The asumStridedBatched functions compute the sum of the magnitudes of elements of real vectors ``x_i``,
|
|
or the sum of the magnitudes of the real and imaginary parts of elements if ``x_i`` is a complex
|
|
vector, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each vector x_i.
|
|
@param[in]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i. incx must be > 0.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stride_x. However, the user should
|
|
take care to ensure that stride_x is of an appropriate size. For a typical
|
|
case, this means stride_x >= n * incx.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[out]
|
|
result
|
|
device pointer or host pointer to array for storing contiguous batchCount results.
|
|
Return value is 0.0 if n, incx<=0.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSasumStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDasumStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScasumStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDzasumStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
double* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSasumStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDasumStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScasumStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDzasumStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
double* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The axpy functions compute a constant ``alpha`` multiplied by vector ``x`` plus vector ``y``.
|
|
|
|
y := alpha * x + y
|
|
|
|
- Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x and y.
|
|
@param[in]
|
|
alpha device pointer or host pointer to specify the scalar alpha.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[out]
|
|
y device pointer storing vector y.
|
|
@param[inout]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHaxpy(hipblasHandle_t handle,
|
|
int n,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* x,
|
|
int incx,
|
|
hipblasHalf* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSaxpy(hipblasHandle_t handle,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
float* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDaxpy(hipblasHandle_t handle,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
double* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCaxpy(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipComplex* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZaxpy(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipDoubleComplex* y,
|
|
int incy);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHaxpy_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* x,
|
|
int64_t incx,
|
|
hipblasHalf* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSaxpy_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
float* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDaxpy_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
double* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCaxpy_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipComplex* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZaxpy_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipDoubleComplex* y,
|
|
int64_t incy);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The axpyBatched functions compute ``y := alpha * x + y`` over a set of batched vectors.
|
|
|
|
- Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x and y.
|
|
@param[in]
|
|
alpha specifies the scalar alpha.
|
|
@param[in]
|
|
x pointer storing vector x on the GPU.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[out]
|
|
y pointer storing vector y on the GPU.
|
|
@param[inout]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHaxpyBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* const x[],
|
|
int incx,
|
|
hipblasHalf* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSaxpyBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int incx,
|
|
float* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDaxpyBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int incx,
|
|
double* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCaxpyBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
hipComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZaxpyBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
hipDoubleComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHaxpyBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* const x[],
|
|
int64_t incx,
|
|
hipblasHalf* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSaxpyBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
float* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDaxpyBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
double* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCaxpyBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
hipComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZaxpyBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The axpyStridedBatched functions compute ``y := alpha * x + y`` over a set of strided batched vectors.
|
|
|
|
- Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
@param[in]
|
|
alpha specifies the scalar alpha.
|
|
@param[in]
|
|
x pointer storing vector x on the GPU.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
specifies the increment between vectors of x.
|
|
@param[out]
|
|
y pointer storing vector y on the GPU.
|
|
@param[inout]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
specifies the increment between vectors of y.
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHaxpyStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipblasHalf* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSaxpyStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDaxpyStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCaxpyStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZaxpyStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHaxpyStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipblasHalf* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSaxpyStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDaxpyStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCaxpyStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZaxpyStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The copy functions copy each element ``x[i]`` into ``y[i]``, for ``i`` = 1 , ... , ``n``.
|
|
|
|
y := x,
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x to be copied to y.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[out]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasScopy(hipblasHandle_t handle, int n, const float* x, int incx, float* y, int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasDcopy(hipblasHandle_t handle, int n, const double* x, int incx, double* y, int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCcopy(
|
|
hipblasHandle_t handle, int n, const hipComplex* x, int incx, hipComplex* y, int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZcopy(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipDoubleComplex* y,
|
|
int incy);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScopy_64(
|
|
hipblasHandle_t handle, int64_t n, const float* x, int64_t incx, float* y, int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDcopy_64(
|
|
hipblasHandle_t handle, int64_t n, const double* x, int64_t incx, double* y, int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCcopy_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipComplex* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZcopy_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipDoubleComplex* y,
|
|
int64_t incy);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The copyBatched functions copy each element ``x_i[j]`` into ``y_i[j]``, for ``j`` = 1 , ... , ``n``; ``i`` = 1 , ... , ``batchCount``.
|
|
|
|
y_i := x_i,
|
|
|
|
where (``x_i``, ``y_i``) is the ``i``-th instance of the batch.
|
|
``x_i`` and ``y_i`` are vectors.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i to be copied to y_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each vector x_i.
|
|
@param[out]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each vector y_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScopyBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* const x[],
|
|
int incx,
|
|
float* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDcopyBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* const x[],
|
|
int incx,
|
|
double* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCcopyBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
hipComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZcopyBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
hipDoubleComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScopyBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
float* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDcopyBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
double* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCcopyBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
hipComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZcopyBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The copyStridedBatched functions copy each element ``x_i[j]`` into ``y_i[j]``, for ``j`` = 1 , ... , ``n``; ``i`` = 1 , ... , ``batchCount``.
|
|
|
|
y_i := x_i,
|
|
|
|
where (``x_i``, ``y_i``) is the ``i``-th instance of the batch.
|
|
``x_i`` and ``y_i`` are vectors.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i to be copied to y_i.
|
|
@param[in]
|
|
x device pointer to the first vector (x_1) in the batch.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increments for the elements of vectors x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stridex. However, the user should
|
|
ensure that stridex is of an appropriate size. For a typical
|
|
case, this means stridex >= n * incx.
|
|
@param[out]
|
|
y device pointer to the first vector (y_1) in the batch.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of vectors y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
There are no restrictions placed on stridey. However, the user should
|
|
ensure that stridey is of an appropriate size. For a typical
|
|
case this means stridey >= n * incy. stridey should be non zero.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScopyStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDcopyStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCcopyStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZcopyStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScopyStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDcopyStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCcopyStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZcopyStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The dot(u) functions performs the dot product of vectors ``x`` and ``y``.
|
|
|
|
result = x * y;
|
|
|
|
The dotc functions performs the dot product of the conjugate of complex vector ``x`` and complex vector ``y``.
|
|
|
|
result = conjugate (x) * y;
|
|
|
|
- Supported precisions in rocBLAS : ``h``, ``bf``, ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x and y.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[inout]
|
|
result
|
|
device pointer or host pointer to store the dot product.
|
|
Return value is 0.0 if n <= 0.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHdot(hipblasHandle_t handle,
|
|
int n,
|
|
const hipblasHalf* x,
|
|
int incx,
|
|
const hipblasHalf* y,
|
|
int incy,
|
|
hipblasHalf* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasBfdot(hipblasHandle_t handle,
|
|
int n,
|
|
const hipblasBfloat16* x,
|
|
int incx,
|
|
const hipblasBfloat16* y,
|
|
int incy,
|
|
hipblasBfloat16* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdot(hipblasHandle_t handle,
|
|
int n,
|
|
const float* x,
|
|
int incx,
|
|
const float* y,
|
|
int incy,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdot(hipblasHandle_t handle,
|
|
int n,
|
|
const double* x,
|
|
int incx,
|
|
const double* y,
|
|
int incy,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotc(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotu(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotc(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipDoubleComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotu(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipDoubleComplex* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHdot_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipblasHalf* x,
|
|
int64_t incx,
|
|
const hipblasHalf* y,
|
|
int64_t incy,
|
|
hipblasHalf* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasBfdot_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipblasBfloat16* x,
|
|
int64_t incx,
|
|
const hipblasBfloat16* y,
|
|
int64_t incy,
|
|
hipblasBfloat16* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdot_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* x,
|
|
int64_t incx,
|
|
const float* y,
|
|
int64_t incy,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdot_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* x,
|
|
int64_t incx,
|
|
const double* y,
|
|
int64_t incy,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotc_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotu_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotc_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipDoubleComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotu_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipDoubleComplex* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The dot(u)Batched functions perform a batch of dot products of vectors ``x`` and ``y``.
|
|
|
|
result_i = x_i * y_i;
|
|
|
|
The dotcBatched functions performs a batch of dot products of the conjugate of complex vector ``x`` and complex vector ``y``.
|
|
|
|
result_i = conjugate (x_i) * y_i;
|
|
|
|
where (``x_i``, ``y_i``) is the ``i``-th instance of the batch and
|
|
``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``h``, ``bf``, ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i and y_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[inout]
|
|
result
|
|
device array or host array of batchCount size to store the dot products of each batch.
|
|
Returns 0.0 for each element if n <= 0.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHdotBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipblasHalf* const x[],
|
|
int incx,
|
|
const hipblasHalf* const y[],
|
|
int incy,
|
|
int batchCount,
|
|
hipblasHalf* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasBfdotBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipblasBfloat16* const x[],
|
|
int incx,
|
|
const hipblasBfloat16* const y[],
|
|
int incy,
|
|
int batchCount,
|
|
hipblasBfloat16* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdotBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* const x[],
|
|
int incx,
|
|
const float* const y[],
|
|
int incy,
|
|
int batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdotBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* const x[],
|
|
int incx,
|
|
const double* const y[],
|
|
int incy,
|
|
int batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotcBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* const y[],
|
|
int incy,
|
|
int batchCount,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotuBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* const y[],
|
|
int incy,
|
|
int batchCount,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotcBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* const y[],
|
|
int incy,
|
|
int batchCount,
|
|
hipDoubleComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotuBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* const y[],
|
|
int incy,
|
|
int batchCount,
|
|
hipDoubleComplex* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHdotBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipblasHalf* const x[],
|
|
int64_t incx,
|
|
const hipblasHalf* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount,
|
|
hipblasHalf* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasBfdotBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipblasBfloat16* const x[],
|
|
int64_t incx,
|
|
const hipblasBfloat16* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount,
|
|
hipblasBfloat16* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdotBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
const float* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdotBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
const double* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotcBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotuBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotcBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount,
|
|
hipDoubleComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotuBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount,
|
|
hipDoubleComplex* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The dot(u)StridedBatched functions perform a batch of dot products of vectors ``x`` and ``y``.
|
|
|
|
result_i = x_i * y_i;
|
|
|
|
The dotcStridedBatched functions perform a batch of dot products of the conjugate of complex vector ``x`` and complex vector ``y``.
|
|
|
|
result_i = conjugate (x_i) * y_i;
|
|
|
|
where (``x_i``, ``y_i``) is the ``i``-th instance of the batch and
|
|
``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``h``, ``bf``, ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i and y_i.
|
|
@param[in]
|
|
x device pointer to the first vector (x_1) in the batch.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
@param[in]
|
|
y device pointer to the first vector (y_1) in the batch.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[inout]
|
|
result
|
|
device array or host array of batchCount size to store the dot products of each batch.
|
|
Returns 0.0 for each element if n <= 0.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHdotStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipblasHalf* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipblasHalf* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount,
|
|
hipblasHalf* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasBfdotStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipblasBfloat16* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipblasBfloat16* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount,
|
|
hipblasBfloat16* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdotStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdotStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotcStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotuStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotcStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount,
|
|
hipDoubleComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotuStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount,
|
|
hipDoubleComplex* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHdotStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipblasHalf* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipblasHalf* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount,
|
|
hipblasHalf* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasBfdotStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipblasBfloat16* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipblasBfloat16* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount,
|
|
hipblasBfloat16* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdotStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdotStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotcStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdotuStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount,
|
|
hipComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotcStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount,
|
|
hipDoubleComplex* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdotuStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount,
|
|
hipDoubleComplex* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The nrm2 functions compute the Euclidean norm of a real or complex vector.
|
|
|
|
result := sqrt( x'*x ) for real vectors
|
|
result := sqrt( x**H*x ) for complex vectors
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``sc``, and ``dz``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``sc``, and ``dz``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of y.
|
|
@param[inout]
|
|
result
|
|
device pointer or host pointer to store the nrm2 product.
|
|
Return value is 0.0 if n, incx<=0.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasSnrm2(hipblasHandle_t handle, int n, const float* x, int incx, float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasDnrm2(hipblasHandle_t handle, int n, const double* x, int incx, double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasScnrm2(hipblasHandle_t handle, int n, const hipComplex* x, int incx, float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDznrm2(
|
|
hipblasHandle_t handle, int n, const hipDoubleComplex* x, int incx, double* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasSnrm2_64(hipblasHandle_t handle, int64_t n, const float* x, int64_t incx, float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDnrm2_64(
|
|
hipblasHandle_t handle, int64_t n, const double* x, int64_t incx, double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScnrm2_64(
|
|
hipblasHandle_t handle, int64_t n, const hipComplex* x, int64_t incx, float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDznrm2_64(
|
|
hipblasHandle_t handle, int64_t n, const hipDoubleComplex* x, int64_t incx, double* result);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The nrm2Batched functions compute the Euclidean norm over a batch of real or complex vectors.
|
|
|
|
result := sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batchCount
|
|
result := sqrt( x_i**H*x_i ) for complex vectors x, for i = 1, ..., batchCount
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``sc``, and ``dz``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each x_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i. incx must be > 0.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[out]
|
|
result
|
|
device pointer or host pointer to array of batchCount size for nrm2 results.
|
|
Return value is 0.0 for each element if n <= 0, incx<=0.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSnrm2Batched(
|
|
hipblasHandle_t handle, int n, const float* const x[], int incx, int batchCount, float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDnrm2Batched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* const x[],
|
|
int incx,
|
|
int batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScnrm2Batched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
int batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDznrm2Batched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount,
|
|
double* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSnrm2Batched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDnrm2Batched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScnrm2Batched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDznrm2Batched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
double* result);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The nrm2StridedBatched functions compute the Euclidean norm over a batch of real or complex vectors.
|
|
|
|
:= sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batchCount
|
|
:= sqrt( x_i**H*x_i ) for complex vectors, for i = 1, ..., batchCount
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``sc``, and ``dz``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each x_i.
|
|
@param[in]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i. incx must be > 0.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stridex. However, the user should
|
|
ensure that stridex is of an appropriate size. For a typical
|
|
case, this means stridex >= n * incx.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[out]
|
|
result
|
|
device pointer or host pointer to array for storing contiguous batchCount results.
|
|
Return value is 0.0 for each element if n <= 0, incx<=0.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSnrm2StridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDnrm2StridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScnrm2StridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDznrm2StridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
double* result);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSnrm2StridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDnrm2StridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
double* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScnrm2StridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
float* result);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDznrm2StridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
double* result);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rot functions apply the Givens rotation matrix defined by ``c=cos(alpha)`` and ``s=sin(alpha)`` to vectors ``x`` and ``y``.
|
|
Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``sc``, and ``dz``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, ``z``, ``cs``, and ``zd``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in the x and y vectors.
|
|
@param[inout]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between elements of x.
|
|
@param[inout]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment between elements of y.
|
|
@param[in]
|
|
c device pointer or host pointer storing the scalar cosine component of the rotation matrix.
|
|
@param[in]
|
|
s device pointer or host pointer storing the scalar sine component of the rotation matrix.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrot(hipblasHandle_t handle,
|
|
int n,
|
|
float* x,
|
|
int incx,
|
|
float* y,
|
|
int incy,
|
|
const float* c,
|
|
const float* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrot(hipblasHandle_t handle,
|
|
int n,
|
|
double* x,
|
|
int incx,
|
|
double* y,
|
|
int incy,
|
|
const double* c,
|
|
const double* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCrot(hipblasHandle_t handle,
|
|
int n,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipComplex* y,
|
|
int incy,
|
|
const float* c,
|
|
const hipComplex* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsrot(hipblasHandle_t handle,
|
|
int n,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipComplex* y,
|
|
int incy,
|
|
const float* c,
|
|
const float* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrot(hipblasHandle_t handle,
|
|
int n,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
const double* c,
|
|
const hipDoubleComplex* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdrot(hipblasHandle_t handle,
|
|
int n,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
const double* c,
|
|
const double* s);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrot_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
float* x,
|
|
int64_t incx,
|
|
float* y,
|
|
int64_t incy,
|
|
const float* c,
|
|
const float* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrot_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
double* x,
|
|
int64_t incx,
|
|
double* y,
|
|
int64_t incy,
|
|
const double* c,
|
|
const double* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCrot_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
const float* c,
|
|
const hipComplex* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsrot_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
const float* c,
|
|
const float* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrot_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
const double* c,
|
|
const hipDoubleComplex* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdrot_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
const double* c,
|
|
const double* s);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rotBatched functions apply the Givens rotation matrix defined by ``c=cos(alpha)`` and ``s=sin(alpha)`` to batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., ``batchCount``.
|
|
Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``sc``, and ``dz``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each x_i and y_i vectors.
|
|
@param[inout]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between elements of each x_i.
|
|
@param[inout]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment between elements of each y_i.
|
|
@param[in]
|
|
c device pointer or host pointer to the scalar cosine component of the rotation matrix.
|
|
@param[in]
|
|
s device pointer or host pointer to the scalar sine component of the rotation matrix.
|
|
@param[in]
|
|
batchCount [int]
|
|
the number of x and y arrays, that is, the number of batches.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotBatched(hipblasHandle_t handle,
|
|
int n,
|
|
float* const x[],
|
|
int incx,
|
|
float* const y[],
|
|
int incy,
|
|
const float* c,
|
|
const float* s,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotBatched(hipblasHandle_t handle,
|
|
int n,
|
|
double* const x[],
|
|
int incx,
|
|
double* const y[],
|
|
int incy,
|
|
const double* c,
|
|
const double* s,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCrotBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipComplex* const x[],
|
|
int incx,
|
|
hipComplex* const y[],
|
|
int incy,
|
|
const float* c,
|
|
const hipComplex* s,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsrotBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipComplex* const x[],
|
|
int incx,
|
|
hipComplex* const y[],
|
|
int incy,
|
|
const float* c,
|
|
const float* s,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrotBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipDoubleComplex* const x[],
|
|
int incx,
|
|
hipDoubleComplex* const y[],
|
|
int incy,
|
|
const double* c,
|
|
const hipDoubleComplex* s,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdrotBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipDoubleComplex* const x[],
|
|
int incx,
|
|
hipDoubleComplex* const y[],
|
|
int incy,
|
|
const double* c,
|
|
const double* s,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
float* const x[],
|
|
int64_t incx,
|
|
float* const y[],
|
|
int64_t incy,
|
|
const float* c,
|
|
const float* s,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
double* const x[],
|
|
int64_t incx,
|
|
double* const y[],
|
|
int64_t incy,
|
|
const double* c,
|
|
const double* s,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCrotBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipComplex* const x[],
|
|
int64_t incx,
|
|
hipComplex* const y[],
|
|
int64_t incy,
|
|
const float* c,
|
|
const hipComplex* s,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsrotBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipComplex* const x[],
|
|
int64_t incx,
|
|
hipComplex* const y[],
|
|
int64_t incy,
|
|
const float* c,
|
|
const float* s,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrotBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
const double* c,
|
|
const hipDoubleComplex* s,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdrotBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
const double* c,
|
|
const double* s,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rotStridedBatched functions apply the Givens rotation matrix defined by ``c=cos(alpha)`` and ``s=sin(alpha)`` to strided batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., ``batchCount``.
|
|
Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``sc``, and ``dz``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each x_i and y_i vectors.
|
|
@param[inout]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
specifies the increment from the beginning of x_i to the beginning of x_(i+1).
|
|
@param[inout]
|
|
y device pointer to the first vector y_1.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment between elements of each y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
specifies the increment from the beginning of y_i to the beginning of y_(i+1).
|
|
@param[in]
|
|
c device pointer or host pointer to the scalar cosine component of the rotation matrix.
|
|
@param[in]
|
|
s device pointer or host pointer to the scalar sine component of the rotation matrix.
|
|
@param[in]
|
|
batchCount [int]
|
|
the number of x and y arrays, that is, the number of batches.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
const float* c,
|
|
const float* s,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
const double* c,
|
|
const double* s,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCrotStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
const float* c,
|
|
const hipComplex* s,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsrotStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
const float* c,
|
|
const float* s,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrotStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
const double* c,
|
|
const hipDoubleComplex* s,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdrotStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
const double* c,
|
|
const double* s,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
const float* c,
|
|
const float* s,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
const double* c,
|
|
const double* s,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCrotStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
const float* c,
|
|
const hipComplex* s,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsrotStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
const float* c,
|
|
const float* s,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrotStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
const double* c,
|
|
const hipDoubleComplex* s,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdrotStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
const double* c,
|
|
const double* s,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rotg functions create the Givens rotation matrix for the vector ``(a b)``.
|
|
Scalars ``c`` and ``s`` and arrays ``a`` and ``b`` can be stored in either host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the CPU until the GPU has finished and the results are available in host memory.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_DEVICE``, this function returns immediately and synchronization is required to read the results.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[inout]
|
|
a device pointer or host pointer to the input vector element, overwritten with r.
|
|
@param[inout]
|
|
b device pointer or host pointer to the input vector element, overwritten with z.
|
|
@param[inout]
|
|
c device pointer or host pointer to the cosine element of the Givens rotation.
|
|
@param[inout]
|
|
s device pointer or host pointer to the sine element of the Givens rotation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasSrotg(hipblasHandle_t handle, float* a, float* b, float* c, float* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasDrotg(hipblasHandle_t handle, double* a, double* b, double* c, double* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasCrotg(hipblasHandle_t handle, hipComplex* a, hipComplex* b, float* c, hipComplex* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrotg(hipblasHandle_t handle,
|
|
hipDoubleComplex* a,
|
|
hipDoubleComplex* b,
|
|
double* c,
|
|
hipDoubleComplex* s);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasSrotg_64(hipblasHandle_t handle, float* a, float* b, float* c, float* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasDrotg_64(hipblasHandle_t handle, double* a, double* b, double* c, double* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasCrotg_64(hipblasHandle_t handle, hipComplex* a, hipComplex* b, float* c, hipComplex* s);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrotg_64(hipblasHandle_t handle,
|
|
hipDoubleComplex* a,
|
|
hipDoubleComplex* b,
|
|
double* c,
|
|
hipDoubleComplex* s);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rotgBatched functions create the Givens rotation matrix for the batched vectors ``(a_i b_i)``, for ``i`` = 1, ..., ``batchCount``.
|
|
``a``, ``b``, ``c``, and ``s`` can be stored in either host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the CPU until the GPU has finished and the results are available in host memory.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_DEVICE``, this function returns immediately and synchronization is required to read the results.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[inout]
|
|
a device array of device pointers storing each single input vector element a_i, overwritten with r_i.
|
|
@param[inout]
|
|
b device array of device pointers storing each single input vector element b_i, overwritten with z_i.
|
|
@param[inout]
|
|
c device array of device pointers storing each cosine element of the Givens rotation for the batch.
|
|
@param[inout]
|
|
s device array of device pointers storing each sine element of the Givens rotation for the batch.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of batches (length of arrays a, b, c, and s).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotgBatched(hipblasHandle_t handle,
|
|
float* const a[],
|
|
float* const b[],
|
|
float* const c[],
|
|
float* const s[],
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotgBatched(hipblasHandle_t handle,
|
|
double* const a[],
|
|
double* const b[],
|
|
double* const c[],
|
|
double* const s[],
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCrotgBatched(hipblasHandle_t handle,
|
|
hipComplex* const a[],
|
|
hipComplex* const b[],
|
|
float* const c[],
|
|
hipComplex* const s[],
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrotgBatched(hipblasHandle_t handle,
|
|
hipDoubleComplex* const a[],
|
|
hipDoubleComplex* const b[],
|
|
double* const c[],
|
|
hipDoubleComplex* const s[],
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotgBatched_64(hipblasHandle_t handle,
|
|
float* const a[],
|
|
float* const b[],
|
|
float* const c[],
|
|
float* const s[],
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotgBatched_64(hipblasHandle_t handle,
|
|
double* const a[],
|
|
double* const b[],
|
|
double* const c[],
|
|
double* const s[],
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCrotgBatched_64(hipblasHandle_t handle,
|
|
hipComplex* const a[],
|
|
hipComplex* const b[],
|
|
float* const c[],
|
|
hipComplex* const s[],
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrotgBatched_64(hipblasHandle_t handle,
|
|
hipDoubleComplex* const a[],
|
|
hipDoubleComplex* const b[],
|
|
double* const c[],
|
|
hipDoubleComplex* const s[],
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rotgStridedBatched functions create the Givens rotation matrix for the strided batched vectors ``(a_i b_i)``, for ``i`` = 1, ..., ``batchCount``.
|
|
``a``, ``b``, ``c``, and ``s`` can be stored in either host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the CPU until the GPU has finished and the results are available in host memory.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function returns immediately and synchronization is required to read the results.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[inout]
|
|
a device strided_batched pointer or host strided_batched pointer to the first single input vector element a_1, overwritten with r.
|
|
@param[in]
|
|
stridea [hipblasStride]
|
|
distance between elements of a in batch (distance between a_i and a_(i + 1)).
|
|
@param[inout]
|
|
b device strided_batched pointer or host strided_batched pointer to the first single input vector element b_1, overwritten with z.
|
|
@param[in]
|
|
strideb [hipblasStride]
|
|
distance between elements of b in batch (distance between b_i and b_(i + 1)).
|
|
@param[inout]
|
|
c device strided_batched pointer or host strided_batched pointer to the first cosine element of the Givens rotations c_1.
|
|
@param[in]
|
|
stridec [hipblasStride]
|
|
distance between elements of c in batch (distance between c_i and c_(i + 1)).
|
|
@param[inout]
|
|
s device strided_batched pointer or host strided_batched pointer to the sine element of the Givens rotations s_1.
|
|
@param[in]
|
|
strides [hipblasStride]
|
|
distance between elements of s in batch (distance between s_i and s_(i + 1)).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of batches (length of arrays a, b, c, and s).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotgStridedBatched(hipblasHandle_t handle,
|
|
float* a,
|
|
hipblasStride stridea,
|
|
float* b,
|
|
hipblasStride strideb,
|
|
float* c,
|
|
hipblasStride stridec,
|
|
float* s,
|
|
hipblasStride strides,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotgStridedBatched(hipblasHandle_t handle,
|
|
double* a,
|
|
hipblasStride stridea,
|
|
double* b,
|
|
hipblasStride strideb,
|
|
double* c,
|
|
hipblasStride stridec,
|
|
double* s,
|
|
hipblasStride strides,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCrotgStridedBatched(hipblasHandle_t handle,
|
|
hipComplex* a,
|
|
hipblasStride stridea,
|
|
hipComplex* b,
|
|
hipblasStride strideb,
|
|
float* c,
|
|
hipblasStride stridec,
|
|
hipComplex* s,
|
|
hipblasStride strides,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrotgStridedBatched(hipblasHandle_t handle,
|
|
hipDoubleComplex* a,
|
|
hipblasStride stridea,
|
|
hipDoubleComplex* b,
|
|
hipblasStride strideb,
|
|
double* c,
|
|
hipblasStride stridec,
|
|
hipDoubleComplex* s,
|
|
hipblasStride strides,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotgStridedBatched_64(hipblasHandle_t handle,
|
|
float* a,
|
|
hipblasStride stridea,
|
|
float* b,
|
|
hipblasStride strideb,
|
|
float* c,
|
|
hipblasStride stridec,
|
|
float* s,
|
|
hipblasStride strides,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotgStridedBatched_64(hipblasHandle_t handle,
|
|
double* a,
|
|
hipblasStride stridea,
|
|
double* b,
|
|
hipblasStride strideb,
|
|
double* c,
|
|
hipblasStride stridec,
|
|
double* s,
|
|
hipblasStride strides,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCrotgStridedBatched_64(hipblasHandle_t handle,
|
|
hipComplex* a,
|
|
hipblasStride stridea,
|
|
hipComplex* b,
|
|
hipblasStride strideb,
|
|
float* c,
|
|
hipblasStride stridec,
|
|
hipComplex* s,
|
|
hipblasStride strides,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZrotgStridedBatched_64(hipblasHandle_t handle,
|
|
hipDoubleComplex* a,
|
|
hipblasStride stridea,
|
|
hipDoubleComplex* b,
|
|
hipblasStride strideb,
|
|
double* c,
|
|
hipblasStride stridec,
|
|
hipDoubleComplex* s,
|
|
hipblasStride strides,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rotm functions apply the modified Givens rotation matrix defined by ``param`` to vectors ``x`` and ``y``.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : ``s`` and ``d``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in the x and y vectors.
|
|
@param[inout]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between elements of x.
|
|
@param[inout]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment between elements of y.
|
|
@param[in]
|
|
param device vector or host vector of five elements defining the rotation.
|
|
param can be stored in either the host or device memory. The location is specified by calling hipblasSetPointerMode.
|
|
- param[0] = flag
|
|
- param[1] = H11
|
|
- param[2] = H21
|
|
- param[3] = H12
|
|
- param[4] = H22
|
|
The flag parameter defines the form of H:
|
|
- flag = -1 => H = ( H11 H12 H21 H22 )
|
|
- flag = 0 => H = ( 1.0 H12 H21 1.0 )
|
|
- flag = 1 => H = ( H11 1.0 -1.0 H22 )
|
|
- flag = -2 => H = ( 1.0 0.0 0.0 1.0 )
|
|
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotm(
|
|
hipblasHandle_t handle, int n, float* x, int incx, float* y, int incy, const float* param);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotm(
|
|
hipblasHandle_t handle, int n, double* x, int incx, double* y, int incy, const double* param);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotm_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
float* x,
|
|
int64_t incx,
|
|
float* y,
|
|
int64_t incy,
|
|
const float* param);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotm_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
double* x,
|
|
int64_t incx,
|
|
double* y,
|
|
int64_t incy,
|
|
const double* param);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rotmBatched functions apply the modified Givens rotation matrix defined by ``param_i`` to batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in the x and y vectors.
|
|
@param[inout]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between elements of each x_i.
|
|
@param[inout]
|
|
y device array of device pointers storing each vector y_1.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment between elements of each y_i.
|
|
@param[in]
|
|
param device array of device vectors of five elements defining the rotation.
|
|
param can ONLY be stored on the device for the batched version of this function.
|
|
- param[0] = flag
|
|
- param[1] = H11
|
|
- param[2] = H21
|
|
- param[3] = H12
|
|
- param[4] = H22
|
|
The flag parameter defines the form of H:
|
|
- flag = -1 => H = ( H11 H12 H21 H22 )
|
|
- flag = 0 => H = ( 1.0 H12 H21 1.0 )
|
|
- flag = 1 => H = ( H11 1.0 -1.0 H22 )
|
|
- flag = -2 => H = ( 1.0 0.0 0.0 1.0 )
|
|
@param[in]
|
|
batchCount [int]
|
|
the number of x and y arrays, that is, the number of batches.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotmBatched(hipblasHandle_t handle,
|
|
int n,
|
|
float* const x[],
|
|
int incx,
|
|
float* const y[],
|
|
int incy,
|
|
const float* const param[],
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotmBatched(hipblasHandle_t handle,
|
|
int n,
|
|
double* const x[],
|
|
int incx,
|
|
double* const y[],
|
|
int incy,
|
|
const double* const param[],
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotmBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
float* const x[],
|
|
int64_t incx,
|
|
float* const y[],
|
|
int64_t incy,
|
|
const float* const param[],
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotmBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
double* const x[],
|
|
int64_t incx,
|
|
double* const y[],
|
|
int64_t incy,
|
|
const double* const param[],
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rotmStridedBatched functions apply the modified Givens rotation matrix defined by ``param_i`` to strided batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in the x and y vectors.
|
|
@param[inout]
|
|
x device pointer pointing to first strided batched vector x_1.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
specifies the increment between the beginning of x_i and x_(i + 1).
|
|
@param[inout]
|
|
y device pointer pointing to the first strided batched vector y_1.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment between elements of each y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
specifies the increment between the beginning of y_i and y_(i + 1).
|
|
@param[in]
|
|
param device pointer pointing to first array of five elements defining the rotation (param_1).
|
|
param can ONLY be stored on the device for the strided_batched version of this function.
|
|
- param[0] = flag
|
|
- param[1] = H11
|
|
- param[2] = H21
|
|
- param[3] = H12
|
|
- param[4] = H22
|
|
The flag parameter defines the form of H:
|
|
- flag = -1 => H = ( H11 H12 H21 H22 )
|
|
- flag = 0 => H = ( 1.0 H12 H21 1.0 )
|
|
- flag = 1 => H = ( H11 1.0 -1.0 H22 )
|
|
- flag = -2 => H = ( 1.0 0.0 0.0 1.0 )
|
|
@param[in]
|
|
strideParam [hipblasStride]
|
|
specifies the increment between the beginning of param_i and param_(i + 1).
|
|
@param[in]
|
|
batchCount [int]
|
|
the number of x and y arrays, that is, the number of batches.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotmStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
const float* param,
|
|
hipblasStride strideParam,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotmStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
const double* param,
|
|
hipblasStride strideParam,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotmStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
const float* param,
|
|
hipblasStride strideParam,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotmStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
const double* param,
|
|
hipblasStride strideParam,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rotmg functions create the modified Givens rotation matrix for the vector ``(d1 * x1, d2 * y1)``.
|
|
Parameters can be stored in either host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the CPU until the GPU has finished and the results are available in host memory.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_DEVICE``, this function returns immediately and synchronization is required to read the results.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : ``s`` and ``d``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[inout]
|
|
d1 device pointer or host pointer to input scalar that is overwritten.
|
|
@param[inout]
|
|
d2 device pointer or host pointer to input scalar that is overwritten.
|
|
@param[inout]
|
|
x1 device pointer or host pointer to input scalar that is overwritten.
|
|
@param[in]
|
|
y1 device pointer or host pointer to input scalar.
|
|
@param[out]
|
|
param device vector or host vector of five elements defining the rotation.
|
|
param can be stored in either host or device memory. The location is specified by calling hipblasSetPointerMode.
|
|
- param[0] = flag
|
|
- param[1] = H11
|
|
- param[2] = H21
|
|
- param[3] = H12
|
|
- param[4] = H22
|
|
The flag parameter defines the form of H:
|
|
- flag = -1 => H = ( H11 H12 H21 H22 )
|
|
- flag = 0 => H = ( 1.0 H12 H21 1.0 )
|
|
- flag = 1 => H = ( H11 1.0 -1.0 H22 )
|
|
- flag = -2 => H = ( 1.0 0.0 0.0 1.0 )
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotmg(
|
|
hipblasHandle_t handle, float* d1, float* d2, float* x1, const float* y1, float* param);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotmg(
|
|
hipblasHandle_t handle, double* d1, double* d2, double* x1, const double* y1, double* param);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotmg_64(
|
|
hipblasHandle_t handle, float* d1, float* d2, float* x1, const float* y1, float* param);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotmg_64(
|
|
hipblasHandle_t handle, double* d1, double* d2, double* x1, const double* y1, double* param);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rotmgBatched functions create the modified Givens rotation matrix for the batched vectors ``(d1_i * x1_i, d2_i * y1_i)``, for ``i`` = 1, ..., ``batchCount``.
|
|
Parameters can be stored in either host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the CPU until the GPU has finished and the results are available in host memory.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_DEVICE``, this function returns immediately and synchronization is required to read the results.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[inout]
|
|
d1 device batched array or host batched array of input scalars that is overwritten.
|
|
@param[inout]
|
|
d2 device batched array or host batched array of input scalars that is overwritten.
|
|
@param[inout]
|
|
x1 device batched array or host batched array of input scalars that is overwritten.
|
|
@param[in]
|
|
y1 device batched array or host batched array of input scalars.
|
|
@param[out]
|
|
param device batched array or host batched array of vectors of five elements defining the rotation.
|
|
param can be stored in either host or device memory. The location is specified by calling hipblasSetPointerMode.
|
|
- param[0] = flag
|
|
- param[1] = H11
|
|
- param[2] = H21
|
|
- param[3] = H12
|
|
- param[4] = H22
|
|
The flag parameter defines the form of H:
|
|
- flag = -1 => H = ( H11 H12 H21 H22 )
|
|
- flag = 0 => H = ( 1.0 H12 H21 1.0 )
|
|
- flag = 1 => H = ( H11 1.0 -1.0 H22 )
|
|
- flag = -2 => H = ( 1.0 0.0 0.0 1.0 )
|
|
@param[in]
|
|
batchCount [int]
|
|
the number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotmgBatched(hipblasHandle_t handle,
|
|
float* const d1[],
|
|
float* const d2[],
|
|
float* const x1[],
|
|
const float* const y1[],
|
|
float* const param[],
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotmgBatched(hipblasHandle_t handle,
|
|
double* const d1[],
|
|
double* const d2[],
|
|
double* const x1[],
|
|
const double* const y1[],
|
|
double* const param[],
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotmgBatched_64(hipblasHandle_t handle,
|
|
float* const d1[],
|
|
float* const d2[],
|
|
float* const x1[],
|
|
const float* const y1[],
|
|
float* const param[],
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotmgBatched_64(hipblasHandle_t handle,
|
|
double* const d1[],
|
|
double* const d2[],
|
|
double* const x1[],
|
|
const double* const y1[],
|
|
double* const param[],
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The rotmgStridedBatched functions create the modified Givens rotation matrix for the strided batched vectors ``(d1_i * x1_i, d2_i * y1_i)``, for ``i`` = 1, ..., ``batchCount``.
|
|
Parameters can be stored in either host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the CPU until the GPU has finished and the results are available in host memory.
|
|
If the pointer mode is set to ``HIPBLAS_POINTER_MODE_DEVICE``, this function returns immediately and synchronization is required to read the results.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[inout]
|
|
d1 device strided_batched array or host strided_batched array of input scalars that is overwritten.
|
|
@param[in]
|
|
strided1 [hipblasStride]
|
|
specifies the increment between the beginning of d1_i and d1_(i+1).
|
|
@param[inout]
|
|
d2 device strided_batched array or host strided_batched array of input scalars that is overwritten.
|
|
@param[in]
|
|
strided2 [hipblasStride]
|
|
specifies the increment between the beginning of d2_i and d2_(i+1).
|
|
@param[inout]
|
|
x1 device strided_batched array or host strided_batched array of input scalars that is overwritten.
|
|
@param[in]
|
|
stridex1 [hipblasStride]
|
|
specifies the increment between the beginning of x1_i and x1_(i+1).
|
|
@param[in]
|
|
y1 device strided_batched array or host strided_batched array of input scalars.
|
|
@param[in]
|
|
stridey1 [hipblasStride]
|
|
specifies the increment between the beginning of y1_i and y1_(i+1).
|
|
@param[out]
|
|
param device stridedBatched array or host stridedBatched array of vectors of five elements defining the rotation.
|
|
param can be stored in either host or device memory. The location is specified by calling hipblasSetPointerMode.
|
|
- param[0] = flag
|
|
- param[1] = H11
|
|
- param[2] = H21
|
|
- param[3] = H12
|
|
- param[4] = H22
|
|
The flag parameter defines the form of H:
|
|
- flag = -1 => H = ( H11 H12 H21 H22 )
|
|
- flag = 0 => H = ( 1.0 H12 H21 1.0 )
|
|
- flag = 1 => H = ( H11 1.0 -1.0 H22 )
|
|
- flag = -2 => H = ( 1.0 0.0 0.0 1.0 )
|
|
@param[in]
|
|
strideParam [hipblasStride]
|
|
specifies the increment between the beginning of param_i and param_(i + 1).
|
|
@param[in]
|
|
batchCount [int]
|
|
the number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotmgStridedBatched(hipblasHandle_t handle,
|
|
float* d1,
|
|
hipblasStride strided1,
|
|
float* d2,
|
|
hipblasStride strided2,
|
|
float* x1,
|
|
hipblasStride stridex1,
|
|
const float* y1,
|
|
hipblasStride stridey1,
|
|
float* param,
|
|
hipblasStride strideParam,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotmgStridedBatched(hipblasHandle_t handle,
|
|
double* d1,
|
|
hipblasStride strided1,
|
|
double* d2,
|
|
hipblasStride strided2,
|
|
double* x1,
|
|
hipblasStride stridex1,
|
|
const double* y1,
|
|
hipblasStride stridey1,
|
|
double* param,
|
|
hipblasStride strideParam,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSrotmgStridedBatched_64(hipblasHandle_t handle,
|
|
float* d1,
|
|
hipblasStride strided1,
|
|
float* d2,
|
|
hipblasStride strided2,
|
|
float* x1,
|
|
hipblasStride stridex1,
|
|
const float* y1,
|
|
hipblasStride stridey1,
|
|
float* param,
|
|
hipblasStride strideParam,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDrotmgStridedBatched_64(hipblasHandle_t handle,
|
|
double* d1,
|
|
hipblasStride strided1,
|
|
double* d2,
|
|
hipblasStride strided2,
|
|
double* x1,
|
|
hipblasStride stridex1,
|
|
const double* y1,
|
|
hipblasStride stridey1,
|
|
double* param,
|
|
hipblasStride strideParam,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The scal functions scales each element of vector ``x`` with scalar ``alpha``.
|
|
|
|
x := alpha * x
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``cs``, and ``zd``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, ``z``, ``cs``, and ``zd``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x.
|
|
@param[in]
|
|
alpha device pointer or host pointer for the scalar alpha.
|
|
@param[inout]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasSscal(hipblasHandle_t handle, int n, const float* alpha, float* x, int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasDscal(hipblasHandle_t handle, int n, const double* alpha, double* x, int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasCscal(hipblasHandle_t handle, int n, const hipComplex* alpha, hipComplex* x, int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasCsscal(hipblasHandle_t handle, int n, const float* alpha, hipComplex* x, int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZscal(
|
|
hipblasHandle_t handle, int n, const hipDoubleComplex* alpha, hipDoubleComplex* x, int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdscal(
|
|
hipblasHandle_t handle, int n, const double* alpha, hipDoubleComplex* x, int incx);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasSscal_64(hipblasHandle_t handle, int64_t n, const float* alpha, float* x, int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDscal_64(
|
|
hipblasHandle_t handle, int64_t n, const double* alpha, double* x, int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCscal_64(
|
|
hipblasHandle_t handle, int64_t n, const hipComplex* alpha, hipComplex* x, int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsscal_64(
|
|
hipblasHandle_t handle, int64_t n, const float* alpha, hipComplex* x, int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZscal_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
hipDoubleComplex* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdscal_64(
|
|
hipblasHandle_t handle, int64_t n, const double* alpha, hipDoubleComplex* x, int64_t incx);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
\details
|
|
The scalBatched functions scale each element of vector ``x_i`` with scalar ``alpha``, for ``i`` = 1, ... , ``batchCount``.
|
|
|
|
x_i := alpha * x_i
|
|
|
|
where (``x_i``) is the ``i``-th instance of the batch.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``cs``, and ``zd``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i.
|
|
@param[in]
|
|
alpha host pointer or device pointer for the scalar alpha.
|
|
@param[inout]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
specifies the number of batches in x.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSscalBatched(
|
|
hipblasHandle_t handle, int n, const float* alpha, float* const x[], int incx, int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDscalBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* alpha,
|
|
double* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCscalBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
hipComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZscalBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsscalBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* alpha,
|
|
hipComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdscalBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* alpha,
|
|
hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSscalBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* alpha,
|
|
float* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDscalBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* alpha,
|
|
double* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCscalBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZscalBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsscalBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* alpha,
|
|
hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdscalBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* alpha,
|
|
hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
\details
|
|
The scalStridedBatched functions scale each element of vector ``x_i`` with scalar ``alpha``, for ``i`` = 1, ... , ``batchCount``.
|
|
|
|
x_i := alpha * x_i ,
|
|
|
|
where ``(x_i)`` is the ``i``-th instance of the batch.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``cs``, and ``zd``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i.
|
|
@param[in]
|
|
alpha host pointer or device pointer for the scalar alpha.
|
|
@param[inout]
|
|
x device pointer to the first vector (x_1) in the batch.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stride_x. However, the user should
|
|
ensure that stride_x is of an appropriate size. For a typical
|
|
case, this means stride_x >= n * incx.
|
|
@param[in]
|
|
batchCount [int]
|
|
specifies the number of batches in x.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSscalStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* alpha,
|
|
float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDscalStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* alpha,
|
|
double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCscalStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZscalStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsscalStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const float* alpha,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdscalStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
const double* alpha,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSscalStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* alpha,
|
|
float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDscalStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* alpha,
|
|
double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCscalStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZscalStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsscalStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const float* alpha,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdscalStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const double* alpha,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The swap functions interchange vectors ``x`` and ``y``.
|
|
|
|
y := x; x := y
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x and y.
|
|
@param[inout]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[inout]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasSswap(hipblasHandle_t handle, int n, float* x, int incx, float* y, int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasDswap(hipblasHandle_t handle, int n, double* x, int incx, double* y, int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasCswap(hipblasHandle_t handle, int n, hipComplex* x, int incx, hipComplex* y, int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZswap(
|
|
hipblasHandle_t handle, int n, hipDoubleComplex* x, int incx, hipDoubleComplex* y, int incy);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSswap_64(
|
|
hipblasHandle_t handle, int64_t n, float* x, int64_t incx, float* y, int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDswap_64(
|
|
hipblasHandle_t handle, int64_t n, double* x, int64_t incx, double* y, int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCswap_64(
|
|
hipblasHandle_t handle, int64_t n, hipComplex* x, int64_t incx, hipComplex* y, int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZswap_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipDoubleComplex* y,
|
|
int64_t incy);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The swapBatched functions interchange vectors ``x_i`` and ``y_i``, for ``i`` = 1 , ... , ``batchCount``.
|
|
|
|
y_i := x_i; x_i := y_i
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i and y_i.
|
|
@param[inout]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[inout]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSswapBatched(hipblasHandle_t handle,
|
|
int n,
|
|
float* const x[],
|
|
int incx,
|
|
float* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDswapBatched(hipblasHandle_t handle,
|
|
int n,
|
|
double* const x[],
|
|
int incx,
|
|
double* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCswapBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipComplex* const x[],
|
|
int incx,
|
|
hipComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZswapBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipDoubleComplex* const x[],
|
|
int incx,
|
|
hipDoubleComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSswapBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
float* const x[],
|
|
int64_t incx,
|
|
float* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDswapBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
double* const x[],
|
|
int64_t incx,
|
|
double* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCswapBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipComplex* const x[],
|
|
int64_t incx,
|
|
hipComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZswapBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 1 API </b>
|
|
|
|
\details
|
|
The swapStridedBatched functions interchange vectors ``x_i`` and ``y_i``, for ``i`` = 1 , ... , ``batchCount``.
|
|
|
|
y_i := x_i; x_i := y_i
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i and y_i.
|
|
@param[inout]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stridex. However, the user should
|
|
ensure that stridex is of an appropriate size. For a typical
|
|
case, this means stridex >= n * incx.
|
|
@param[inout]
|
|
y device pointer to the first vector y_1.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
There are no restrictions placed on stridey. However, the user should
|
|
ensure that stridey is of an appropriate size. For a typical
|
|
case, this means stridey >= n * incy. stridey should be non zero.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSswapStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDswapStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCswapStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZswapStridedBatched(hipblasHandle_t handle,
|
|
int n,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSswapStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDswapStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCswapStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZswapStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*
|
|
* ===========================================================================
|
|
* level 2 BLAS
|
|
* ===========================================================================
|
|
*/
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The gbmv functions perform one of the matrix-vector operations:
|
|
|
|
y := alpha*A*x + beta*y, or
|
|
y := alpha*A**T*x + beta*y, or
|
|
y := alpha*A**H*x + beta*y,
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are vectors, and ``A`` is an
|
|
``m`` by ``n`` banded matrix with ``kl`` sub-diagonals and ``ku`` super-diagonals.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
trans [hipblasOperation_t]
|
|
indicates whether matrix A is tranposed (conjugated) or not.
|
|
@param[in]
|
|
m [int]
|
|
number of rows of matrix A.
|
|
@param[in]
|
|
n [int]
|
|
number of columns of matrix A.
|
|
@param[in]
|
|
kl [int]
|
|
number of sub-diagonals of A.
|
|
@param[in]
|
|
ku [int]
|
|
number of super-diagonals of A.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device pointer storing banded matrix A.
|
|
The leading (kl + ku + 1) by n part of the matrix contains the coefficients
|
|
of the banded matrix. The leading diagonal resides in row (ku + 1) with
|
|
the first super-diagonal above on the RHS of row ku. The first sub-diagonal
|
|
resides below on the LHS of row ku + 2. This propagates up and down across
|
|
sub/super-diagonals.
|
|
Ex: (m = n = 7; ku = 2, kl = 2)
|
|
1 2 3 0 0 0 0 -> 0 0 3 3 3 3 3
|
|
4 1 2 3 0 0 0 -> 0 2 2 2 2 2 2
|
|
5 4 1 2 3 0 0 -> 1 1 1 1 1 1 1
|
|
0 5 4 1 2 3 0 -> 4 4 4 4 4 4 0
|
|
0 0 5 4 1 2 0 -> 5 5 5 5 5 0 0
|
|
0 0 0 5 4 1 2 -> 0 0 0 0 0 0 0
|
|
0 0 0 0 5 4 1 -> 0 0 0 0 0 0 0
|
|
Note that empty elements that don't correspond to data will not
|
|
be referenced.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A. Must be >= (kl + ku + 1).
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgbmv(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
const float* x,
|
|
int incx,
|
|
const float* beta,
|
|
float* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgbmv(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
const double* x,
|
|
int incx,
|
|
const double* beta,
|
|
double* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgbmv(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgbmv(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgbmv_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
const float* x,
|
|
int64_t incx,
|
|
const float* beta,
|
|
float* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgbmv_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
const double* x,
|
|
int64_t incx,
|
|
const double* beta,
|
|
double* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgbmv_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgbmv_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The gbmvBatched functions perform one of the matrix-vector operations:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i, or
|
|
y_i := alpha*A_i**T*x_i + beta*y_i, or
|
|
y_i := alpha*A_i**H*x_i + beta*y_i,
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``m`` by ``n`` banded matrix with ``kl`` sub-diagonals and ``ku`` super-diagonals,
|
|
for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
trans [hipblasOperation_t]
|
|
indicates whether matrix A is tranposed (conjugated) or not.
|
|
@param[in]
|
|
m [int]
|
|
number of rows of each matrix A_i.
|
|
@param[in]
|
|
n [int]
|
|
number of columns of each matrix A_i.
|
|
@param[in]
|
|
kl [int]
|
|
number of sub-diagonals of each A_i.
|
|
@param[in]
|
|
ku [int]
|
|
number of super-diagonals of each A_i.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device array of device pointers storing each banded matrix A_i.
|
|
The leading (kl + ku + 1) by n part of the matrix contains the coefficients
|
|
of the banded matrix. The leading diagonal resides in row (ku + 1) with
|
|
the first super-diagonal above on the RHS of row ku. The first sub-diagonal
|
|
resides below on the LHS of row ku + 2. This propagates up and down across
|
|
sub/super-diagonals.
|
|
Ex: (m = n = 7; ku = 2, kl = 2)
|
|
1 2 3 0 0 0 0 -> 0 0 3 3 3 3 3
|
|
4 1 2 3 0 0 0 -> 0 2 2 2 2 2 2
|
|
5 4 1 2 3 0 0 -> 1 1 1 1 1 1 1
|
|
0 5 4 1 2 3 0 -> 4 4 4 4 4 4 0
|
|
0 0 5 4 1 2 0 -> 5 5 5 5 5 0 0
|
|
0 0 0 5 4 1 2 -> 0 0 0 0 0 0 0
|
|
0 0 0 0 5 4 1 -> 0 0 0 0 0 0 0
|
|
Note that empty elements that don't correspond to data will not
|
|
be referenced.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i. Must be >= (kl + ku + 1).
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
specifies the number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgbmvBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int lda,
|
|
const float* const x[],
|
|
int incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgbmvBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int lda,
|
|
const double* const x[],
|
|
int incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgbmvBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgbmvBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The gbmvStridedBatched functions perform one of the matrix-vector operations:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i, or
|
|
y_i := alpha*A_i**T*x_i + beta*y_i, or
|
|
y_i := alpha*A_i**H*x_i + beta*y_i,
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``m`` by ``n`` banded matrix with ``kl`` sub-diagonals and ``ku`` super-diagonals,
|
|
for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
trans [hipblasOperation_t]
|
|
indicates whether matrix A is tranposed (conjugated) or not.
|
|
@param[in]
|
|
m [int]
|
|
number of rows of matrix A.
|
|
@param[in]
|
|
n [int]
|
|
number of columns of matrix A.
|
|
@param[in]
|
|
kl [int]
|
|
number of sub-diagonals of A.
|
|
@param[in]
|
|
ku [int]
|
|
number of super-diagonals of A.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device pointer to first banded matrix (A_1).
|
|
The leading (kl + ku + 1) by n part of the matrix contains the coefficients
|
|
of the banded matrix. The leading diagonal resides in row (ku + 1) with
|
|
the first super-diagonal above on the RHS of row ku. The first sub-diagonal
|
|
resides below on the LHS of row ku + 2. This propagates up and down across
|
|
sub/super-diagonals.
|
|
Ex: (m = n = 7; ku = 2, kl = 2)
|
|
1 2 3 0 0 0 0 -> 0 0 3 3 3 3 3
|
|
4 1 2 3 0 0 0 -> 0 2 2 2 2 2 2
|
|
5 4 1 2 3 0 0 -> 1 1 1 1 1 1 1
|
|
0 5 4 1 2 3 0 -> 4 4 4 4 4 4 0
|
|
0 0 5 4 1 2 0 -> 5 5 5 5 5 0 0
|
|
0 0 0 5 4 1 2 -> 0 0 0 0 0 0 0
|
|
0 0 0 0 5 4 1 -> 0 0 0 0 0 0 0
|
|
Note that empty elements that don't correspond to data will not
|
|
be referenced.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A. Must be >= (kl + ku + 1).
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
@param[in]
|
|
x device pointer to first vector (x_1).
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device pointer to first vector (y_1).
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (x_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
specifies the number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
int kl,
|
|
int ku,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t kl,
|
|
int64_t ku,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The gemv functions perform one of the matrix-vector operations:
|
|
|
|
y := alpha*A*x + beta*y, or
|
|
y := alpha*A**T*x + beta*y, or
|
|
y := alpha*A**H*x + beta*y,
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are vectors, and ``A`` is an
|
|
``m`` by ``n`` matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
trans [hipblasOperation_t]
|
|
indicates whether matrix A is tranposed (conjugated) or not.
|
|
@param[in]
|
|
m [int]
|
|
number of rows of matrix A.
|
|
@param[in]
|
|
n [int]
|
|
number of columns of matrix A.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device pointer storing matrix A.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemv(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
const float* x,
|
|
int incx,
|
|
const float* beta,
|
|
float* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemv(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
const double* x,
|
|
int incx,
|
|
const double* beta,
|
|
double* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemv(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemv(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemv_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
const float* x,
|
|
int64_t incx,
|
|
const float* beta,
|
|
float* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemv_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
const double* x,
|
|
int64_t incx,
|
|
const double* beta,
|
|
double* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemv_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemv_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The gemvBatched functions perform a batch of matrix-vector operations:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i, or
|
|
y_i := alpha*A_i**T*x_i + beta*y_i, or
|
|
y_i := alpha*A_i**H*x_i + beta*y_i,
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
trans [hipblasOperation_t]
|
|
indicates whether matrices A_i are tranposed (conjugated) or not.
|
|
@param[in]
|
|
m [int]
|
|
number of rows of each matrix A_i.
|
|
@param[in]
|
|
n [int]
|
|
number of columns of each matrix A_i.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each matrix A_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each vector x_i.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each vector y_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemvBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int lda,
|
|
const float* const x[],
|
|
int incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemvBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int lda,
|
|
const double* const x[],
|
|
int incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemvBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemvBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemvBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemvBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemvBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemvBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The gemvStridedBatched functions perform a batch of matrix-vector operations:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i, or
|
|
y_i := alpha*A_i**T*x_i + beta*y_i, or
|
|
y_i := alpha*A_i**H*x_i + beta*y_i,
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
indicates whether matrices A_i are tranposed (conjugated) or not.
|
|
@param[in]
|
|
m [int]
|
|
number of rows of matrices A_i.
|
|
@param[in]
|
|
n [int]
|
|
number of columns of matrices A_i.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device pointer to the first matrix (A_1) in the batch.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of matrices A_i.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
@param[in]
|
|
x device pointer to the first vector (x_1) in the batch.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of vectors x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stridex. However, the user should
|
|
ensure that stridex is of an appropriate size. When trans equals HIPBLAS_OP_N,
|
|
this typically means stridex >= n * incx. Otherwise, stridex >= m * incx.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device pointer to the first vector (y_1) in the batch.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of vectors y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
There are no restrictions placed on stridey. However, the user should
|
|
ensure that stridey is of an appropriate size. When trans equals HIPBLAS_OP_N,
|
|
this typically means stridey >= m * incy. Otherwise, stridey >= n * incy. stridey should be non zero.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemvStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemvStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemvStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemvStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The ger, geru, and gerc functions perform the matrix-vector operations:
|
|
|
|
A := A + alpha*x*y**T , OR
|
|
A := A + alpha*x*y**H for gerc
|
|
|
|
where ``alpha`` is a scalar, ``x`` and ``y`` are vectors, and ``A`` is an
|
|
``m`` by ``n`` matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
m [int]
|
|
the number of rows of the matrix A.
|
|
@param[in]
|
|
n [int]
|
|
the number of columns of the matrix A.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[inout]
|
|
AP device pointer storing matrix A.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSger(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
const float* y,
|
|
int incy,
|
|
float* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDger(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
const double* y,
|
|
int incy,
|
|
double* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeru(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipComplex* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgerc(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipComplex* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeru(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipDoubleComplex* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgerc(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipDoubleComplex* AP,
|
|
int lda);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSger_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
const float* y,
|
|
int64_t incy,
|
|
float* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDger_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
const double* y,
|
|
int64_t incy,
|
|
double* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeru_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipComplex* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgerc_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipComplex* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeru_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgerc_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The gerBatched, geruBatched, and gercBatched functions perform a batch of the matrix-vector operations:
|
|
|
|
A := A + alpha*x*y**T , OR
|
|
A := A + alpha*x*y**H for gerc
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
m [int]
|
|
the number of rows of each matrix A_i.
|
|
@param[in]
|
|
n [int]
|
|
the number of columns of each matrix A_i.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each vector x_i.
|
|
@param[in]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each vector y_i.
|
|
@param[inout]
|
|
AP device array of device pointers storing each matrix A_i.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgerBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int incx,
|
|
const float* const y[],
|
|
int incy,
|
|
float* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgerBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int incx,
|
|
const double* const y[],
|
|
int incy,
|
|
double* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeruBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* const y[],
|
|
int incy,
|
|
hipComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgercBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* const y[],
|
|
int incy,
|
|
hipComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeruBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* const y[],
|
|
int incy,
|
|
hipDoubleComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgercBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* const y[],
|
|
int incy,
|
|
hipDoubleComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgerBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
const float* const y[],
|
|
int64_t incy,
|
|
float* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgerBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
const double* const y[],
|
|
int64_t incy,
|
|
double* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeruBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* const y[],
|
|
int64_t incy,
|
|
hipComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgercBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* const y[],
|
|
int64_t incy,
|
|
hipComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeruBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgercBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The gerStridedBatched, geruStridedBatched, and gercStridedBatched functions perform the matrix-vector operations:
|
|
|
|
A_i := A_i + alpha*x_i*y_i**T, OR
|
|
A_i := A_i + alpha*x_i*y_i**H for gerc
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
m [int]
|
|
the number of rows of each matrix A_i.
|
|
@param[in]
|
|
n [int]
|
|
the number of columns of each matrix A_i.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer to the first vector (x_1) in the batch.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increments for the elements of each vector x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stridex. However, the user should
|
|
ensure that stridex is of an appropriate size. For a typical
|
|
case, this means stridex >= m * incx.
|
|
@param[inout]
|
|
y device pointer to the first vector (y_1) in the batch.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each vector y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
There are no restrictions placed on stridey. However, the user should
|
|
ensure that stridey is of an appropriate size. For a typical
|
|
case, this means stridey >= n * incy.
|
|
@param[inout]
|
|
AP device pointer to the first matrix (A_1) in the batch.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1)
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgerStridedBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgerStridedBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeruStridedBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgercStridedBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeruStridedBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgercStridedBatched(hipblasHandle_t handle,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgerStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgerStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeruStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgercStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeruStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgercStridedBatched_64(hipblasHandle_t handle,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hbmv functions perform the matrix-vector operations:
|
|
|
|
y := alpha*A*x + beta*y
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n``-element vectors, and ``A ``is an
|
|
``n`` by ``n`` Hermitian band matrix with ``k`` super-diagonals.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : ``c`` and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is being supplied.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is being supplied.
|
|
@param[in]
|
|
n [int]
|
|
the order of the matrix A.
|
|
@param[in]
|
|
k [int]
|
|
the number of super-diagonals of the matrix A. Must be >= 0.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device pointer storing matrix A. Of dimension (lda, n).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The leading (k + 1) by n part of A must contain the upper
|
|
triangular band part of the Hermitian matrix, with the leading
|
|
diagonal in row (k + 1), the first super-diagonal on the RHS
|
|
of row k, and so forth.
|
|
The top left k by x triangle of A will not be referenced.
|
|
Ex (upper, lda = n = 4, k = 1):
|
|
A -> Represented matrix
|
|
(0,0) (5,9) (6,8) (7,7) -> (1, 0) (5, 9) (0, 0) (0, 0)
|
|
(1,0) (2,0) (3,0) (4,0) -> (5,-9) (2, 0) (6, 8) (0, 0)
|
|
(0,0) (0,0) (0,0) (0,0) -> (0, 0) (6,-8) (3, 0) (7, 7)
|
|
(0,0) (0,0) (0,0) (0,0) -> (0, 0) (0, 0) (7,-7) (4, 0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The leading (k + 1) by n part of A must contain the lower
|
|
triangular band part of the Hermitian matrix, with the leading
|
|
diagonal in row (1), the first sub-diagonal on the LHS of
|
|
row 2, and so forth.
|
|
The bottom right k by k triangle of A will not be referenced.
|
|
Ex (lower, lda = 2, n = 4, k = 1):
|
|
A -> Represented matrix
|
|
(1,0) (2,0) (3,0) (4,0) -> (1, 0) (5,-9) (0, 0) (0, 0)
|
|
(5,9) (6,8) (7,7) (0,0) -> (5, 9) (2, 0) (6,-8) (0, 0)
|
|
-> (0, 0) (6, 8) (3, 0) (7,-7)
|
|
-> (0, 0) (0, 0) (7, 7) (4, 0)
|
|
- As a Hermitian matrix, the imaginary part of the main diagonal
|
|
of A will not be referenced and is assumed to be == 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A. Must be >= k + 1.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChbmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhbmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChbmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhbmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hbmvBatched functions perform one of the matrix-vector operations:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n``-element vectors, and ``A_i`` is an
|
|
``n`` by ``n`` Hermitian band matrix with ``k`` super-diagonals, for each batch in ``i`` = [1, ``batchCount``].
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is being supplied.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is being supplied.
|
|
@param[in]
|
|
n [int]
|
|
the order of each matrix A_i.
|
|
@param[in]
|
|
k [int]
|
|
the number of super-diagonals of each matrix A_i. Must be >= 0.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix_i A of dimension (lda, n).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The leading (k + 1) by n part of each A_i must contain the upper
|
|
triangular band part of the Hermitian matrix, with the leading
|
|
diagonal in row (k + 1), the first super-diagonal on the RHS
|
|
of row k, and so forth.
|
|
The top left k by x triangle of each A_i will not be referenced.
|
|
Ex (upper, lda = n = 4, k = 1):
|
|
A -> Represented matrix
|
|
(0,0) (5,9) (6,8) (7,7) -> (1, 0) (5, 9) (0, 0) (0, 0)
|
|
(1,0) (2,0) (3,0) (4,0) -> (5,-9) (2, 0) (6, 8) (0, 0)
|
|
(0,0) (0,0) (0,0) (0,0) -> (0, 0) (6,-8) (3, 0) (7, 7)
|
|
(0,0) (0,0) (0,0) (0,0) -> (0, 0) (0, 0) (7,-7) (4, 0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The leading (k + 1) by n part of each A_i must contain the lower
|
|
triangular band part of the Hermitian matrix, with the leading
|
|
diagonal in row (1), the first sub-diagonal on the LHS of
|
|
row 2, and so forth.
|
|
The bottom right k by k triangle of each A_i will not be referenced.
|
|
Ex (lower, lda = 2, n = 4, k = 1):
|
|
A -> Represented matrix
|
|
(1,0) (2,0) (3,0) (4,0) -> (1, 0) (5,-9) (0, 0) (0, 0)
|
|
(5,9) (6,8) (7,7) (0,0) -> (5, 9) (2, 0) (6,-8) (0, 0)
|
|
-> (0, 0) (6, 8) (3, 0) (7,-7)
|
|
-> (0, 0) (0, 0) (7, 7) (4, 0)
|
|
- As a Hermitian matrix, the imaginary part of the main diagonal
|
|
of each A_i will not be referenced and is assumed to be == 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i. Must be >= max(1, n).
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChbmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhbmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hbmvStridedBatched functions perform one of the matrix-vector operations:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n``-element vectors, and ``A_i`` is an
|
|
``n`` by ``n`` Hermitian band matrix with ``k`` super-diagonals, for each batch in ``i`` = [1, ``batchCount``].
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is being supplied.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is being supplied.
|
|
@param[in]
|
|
n [int]
|
|
the order of each matrix A_i.
|
|
@param[in]
|
|
k [int]
|
|
the number of super-diagonals of each matrix A_i. Must be >= 0.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device array pointing to the first matrix A_1. Each A_i is of dimension (lda, n).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The leading (k + 1) by n part of each A_i must contain the upper
|
|
triangular band part of the Hermitian matrix, with the leading
|
|
diagonal in row (k + 1), the first super-diagonal on the RHS
|
|
of row k, and so forth.
|
|
The top left k by x triangle of each A_i will not be referenced.
|
|
Ex (upper, lda = n = 4, k = 1):
|
|
A -> Represented matrix
|
|
(0,0) (5,9) (6,8) (7,7) -> (1, 0) (5, 9) (0, 0) (0, 0)
|
|
(1,0) (2,0) (3,0) (4,0) -> (5,-9) (2, 0) (6, 8) (0, 0)
|
|
(0,0) (0,0) (0,0) (0,0) -> (0, 0) (6,-8) (3, 0) (7, 7)
|
|
(0,0) (0,0) (0,0) (0,0) -> (0, 0) (0, 0) (7,-7) (4, 0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The leading (k + 1) by n part of each A_i must contain the lower
|
|
triangular band part of the Hermitian matrix, with the leading
|
|
diagonal in row (1), the first sub-diagonal on the LHS of
|
|
row 2, and so forth.
|
|
The bottom right k by k triangle of each A_i will not be referenced.
|
|
Ex (lower, lda = 2, n = 4, k = 1):
|
|
A Represented matrix
|
|
(1,0) (2,0) (3,0) (4,0) -> (1, 0) (5,-9) (0, 0) (0, 0)
|
|
(5,9) (6,8) (7,7) (0,0) -> (5, 9) (2, 0) (6,-8) (0, 0)
|
|
-> (0, 0) (6, 8) (3, 0) (7,-7)
|
|
-> (0, 0) (0, 0) (7, 7) (4, 0)
|
|
- As a Hermitian matrix, the imaginary part of the main diagonal
|
|
of each A_i will not be referenced and is assumed to be == 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i. Must be >= max(1, n).
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
@param[in]
|
|
x device array pointing to the first vector y_1.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device array pointing to the first vector y_1.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hemv functions perform one of the matrix-vector operations:
|
|
|
|
y := alpha*A*x + beta*y
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n``-element vectors, and ``A`` is an
|
|
``n`` by ``n`` Hermitian matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : ``c`` and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: the upper triangular part of the Hermitian matrix A is supplied.
|
|
- HIPBLAS_FILL_MODE_LOWER: the lower triangular part of the Hermitian matrix A is supplied.
|
|
@param[in]
|
|
n [int]
|
|
the order of the matrix A.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device pointer storing matrix A. Of dimension (lda, n).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular part of A must contain
|
|
the upper triangular part of a Hermitian matrix. The lower
|
|
triangular part of A will not be referenced.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular part of A must contain
|
|
the lower triangular part of a Hermitian matrix. The upper
|
|
triangular part of A will not be referenced.
|
|
- As a Hermitian matrix, the imaginary part of the main diagonal
|
|
of A will not be referenced and is assumed to be == 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A. Must be >= max(1, n).
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hemvBatched functions perform one of the matrix-vector operations:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n``-element vectors, and ``A_i`` is an
|
|
``n`` by ``n`` Hermitian matrix, for each batch in ``i`` = [1, ``batchCount``].
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: the upper triangular part of the Hermitian matrix A is supplied.
|
|
- HIPBLAS_FILL_MODE_LOWER: the lower triangular part of the Hermitian matrix A is supplied.
|
|
@param[in]
|
|
n [int]
|
|
the order of each matrix A_i.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i of dimension (lda, n).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular part of each A_i must contain
|
|
the upper triangular part of a Hermitian matrix. The lower
|
|
triangular part of each A_i will not be referenced.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular part of each A_i must contain
|
|
the lower triangular part of a Hermitian matrix. The upper
|
|
triangular part of each A_i will not be referenced.
|
|
- As a Hermitian matrix, the imaginary part of the main diagonal
|
|
of each A_i will not be referenced and is assumed to be == 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i. Must be >= max(1, n).
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hemvStridedBatched functions perform one of the matrix-vector operations:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n``-element vectors, and ``A_i`` is an
|
|
``n`` by ``n`` Hermitian matrix, for each batch in ``i`` = [1, ``batchCount``].
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: the upper triangular part of the Hermitian matrix A is supplied.
|
|
- HIPBLAS_FILL_MODE_LOWER: the lower triangular part of the Hermitian matrix A is supplied.
|
|
@param[in]
|
|
n [int]
|
|
the order of each matrix A_i.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i of dimension (lda, n).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular part of each A_i must contain
|
|
the upper triangular part of a Hermitian matrix. The lower
|
|
triangular part of each A_i will not be referenced.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular part of each A_i must contain
|
|
the lower triangular part of a Hermitian matrix. The upper
|
|
triangular part of each A_i will not be referenced.
|
|
- As a Hermitian matrix, the imaginary part of the main diagonal
|
|
of each A_i will not be referenced and is assumed to be == 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i. Must be >= max(1, n).
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one (A_i) to the next (A_i+1).
|
|
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The her functions perform the matrix-vector operations:
|
|
|
|
A := A + alpha*x*x**H
|
|
|
|
where ``alpha`` is a real scalar, ``x`` is a vector, and ``A`` is an
|
|
``n`` by ``n`` Hermitian matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : ``c`` and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied in A.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied in A.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of matrix A. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[inout]
|
|
AP device pointer storing the specified triangular portion of
|
|
the Hermitian matrix A. Of size (lda * n).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of the Hermitian matrix A is supplied. The lower
|
|
triangluar portion will not be touched.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of the Hermitian matrix A is supplied. The upper
|
|
triangular portion will not be touched.
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A. Must be at least max(1, n).
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipComplex* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipDoubleComplex* AP,
|
|
int lda);
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipComplex* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
herBatched performs the matrix-vector operations:
|
|
|
|
A_i := A_i + alpha*x_i*x_i**H
|
|
|
|
where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in A.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in A.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[inout]
|
|
AP device array of device pointers storing the specified triangular portion of
|
|
each Hermitian matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at least size batchCount.
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each Hermitian matrix A_i is supplied. The lower triangular portion
|
|
of each A_i will not be touched.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each Hermitian matrix A_i is supplied. The upper triangular portion
|
|
of each A_i will not be touched.
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i. Must be at least max(1, n).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
hipComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
hipDoubleComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
hipComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The herStridedBatched functions perform the matrix-vector operations:
|
|
|
|
A_i := A_i + alpha*x_i*x_i**H
|
|
|
|
where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an
|
|
``n`` by ``n`` Hermitian matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in A.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in A.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer pointing to the first vector (x_1).
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
@param[inout]
|
|
AP device array of device pointers storing the specified triangular portion of
|
|
each Hermitian matrix A_i. Points to the first matrix (A_1).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each Hermitian matrix A_i is supplied. The lower triangular
|
|
portion of each A_i will not be touched.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each Hermitian matrix A_i is supplied. The upper triangular
|
|
portion of each A_i will not be touched.
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one (A_i) to the next (A_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The her2 functions perform the matrix-vector operations:
|
|
|
|
A := A + alpha*x*y**H + conj(alpha)*y*x**H
|
|
|
|
where ``alpha`` is a complex scalar, ``x`` and ``y`` are vectors, and ``A`` is an
|
|
n by n Hermitian matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : ``c`` and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of matrix A. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[inout]
|
|
AP device pointer storing the specified triangular portion of
|
|
the Hermitian matrix A. Of size (lda, n).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of the Hermitian matrix A is supplied. The lower triangular
|
|
portion of A will not be touched.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of the Hermitian matrix A is supplied. The upper triangular
|
|
portion of A will not be touched.
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A. Must be at least max(lda, 1).
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipComplex* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipDoubleComplex* AP,
|
|
int lda);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipComplex* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The her2Batched functions perform the matrix-vector operations:
|
|
|
|
A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H
|
|
|
|
where ``alpha`` is a complex scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` Hermitian matrix for each batch in ``i`` = [1, ``batchCount``].
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[inout]
|
|
AP device array of device pointers storing the specified triangular portion of
|
|
each Hermitian matrix A_i of size (lda, n).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each Hermitian matrix A_i is supplied. The lower triangular
|
|
portion of each A_i will not be touched.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each Hermitian matrix A_i is supplied. The upper triangular
|
|
portion of each A_i will not be touched.
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i. Must be at least max(lda, 1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2Batched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* const y[],
|
|
int incy,
|
|
hipComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2Batched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* const y[],
|
|
int incy,
|
|
hipDoubleComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2Batched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* const y[],
|
|
int64_t incy,
|
|
hipComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2Batched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The her2StridedBatched functions perform the matrix-vector operations:
|
|
|
|
A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H
|
|
|
|
where ``alpha`` is a complex scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` Hermitian matrix for each batch in ``i`` = [1, ``batchCount``].
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer pointing to the first vector x_1.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
specifies the stride between the beginning of one vector (x_i) and the next (x_i+1).
|
|
@param[in]
|
|
y device pointer pointing to the first vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
specifies the stride between the beginning of one vector (y_i) and the next (y_i+1).
|
|
@param[inout]
|
|
AP device pointer pointing to the first matrix (A_1). Stores the specified triangular portion of
|
|
each Hermitian matrix A_i.
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each Hermitian matrix A_i is supplied. The lower triangular
|
|
portion of each A_i will not be touched.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each Hermitian matrix A_i is supplied. The upper triangular
|
|
portion of each A_i will not be touched.
|
|
- Note that the imaginary part of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i. Must be at least max(lda, 1).
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
specifies the stride between the beginning of one matrix (A_i) and the next (A_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2StridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2StridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2StridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2StridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hpmv functions perform the matrix-vector operation:
|
|
|
|
y := alpha*A*x + beta*y
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n``-element vectors and ``A`` is an
|
|
``n`` by ``n`` Hermitian matrix, supplied in packed form (see description below).
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : ``c`` and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: the upper triangular part of the Hermitian matrix A is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: the lower triangular part of the Hermitian matrix A is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the order of the matrix A. Must be >= 0.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device pointer storing the packed version of the specified triangular portion of
|
|
the Hermitian matrix A. Of at least size ((n * (n + 1)) / 2).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of the Hermitian matrix A is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3)
|
|
(1, 0) (2, 1) (3, 2)
|
|
(2,-1) (4, 0) (5,-1) -> [(1,0), (2,1), (4,0), (3,2), (5,-1), (6,0)]
|
|
(3,-2) (5, 1) (6, 0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of the Hermitian matrix A is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3)
|
|
(1, 0) (2, 1) (3, 2)
|
|
(2,-1) (4, 0) (5,-1) -> [(1,0), (2,-1), (3,-2), (4,0), (5,1), (6,0)]
|
|
(3,-2) (5, 1) (6, 0)
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hpmvBatched functions performs the matrix-vector operation:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n``-element vectors, and ``A_i`` is an
|
|
``n`` by ``n`` Hermitian matrix, supplied in packed form (see description below),
|
|
for each batch in ``i`` = [1, ``batchCount``].
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: the upper triangular part of each Hermitian matrix A_i is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: the lower triangular part of each Hermitian matrix A_i is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the order of each matrix A_i.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device pointer of device pointers storing the packed version of the specified triangular
|
|
portion of each Hermitian matrix A_i. Each A_i is of at least size ((n * (n + 1)) / 2).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that each AP_i contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3)
|
|
(1, 0) (2, 1) (3, 2)
|
|
(2,-1) (4, 0) (5,-1) -> [(1,0), (2,1), (4,0), (3,2), (5,-1), (6,0)]
|
|
(3,-2) (5, 1) (6, 0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that each AP_i contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3)
|
|
(1, 0) (2, 1) (3, 2)
|
|
(2,-1) (4, 0) (5,-1) -> [(1,0), (2,-1), (3,-2), (4,0), (5,1), (6,0)]
|
|
(3,-2) (5, 1) (6, 0)
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hpmvStridedBatched functions perform the matrix-vector operation:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n``-element vectors, and ``A_i`` is an
|
|
``n`` by ``n`` Hermitian matrix, supplied in packed form (see description below),
|
|
for each batch in ``i`` = [1, ``batchCount``].
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: the upper triangular part of each Hermitian matrix A_i is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: the lower triangular part of each Hermitian matrix A_i is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the order of each matrix A_i.
|
|
@param[in]
|
|
alpha device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device pointer pointing to the beginning of the first matrix (AP_1). Stores the packed
|
|
version of the specified triangular portion of each Hermitian matrix AP_i of size ((n * (n + 1)) / 2).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that each AP_i contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3)
|
|
(1, 0) (2, 1) (3, 2)
|
|
(2,-1) (4, 0) (5,-1) -> [(1,0), (2,1), (4,0), (3,2), (5,-1), (6,0)]
|
|
(3,-2) (5, 1) (6, 0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that each AP_i contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3)
|
|
(1, 0) (2, 1) (3, 2)
|
|
(2,-1) (4, 0) (5,-1) -> [(1,0), (2,-1), (3,-2), (4,0), (5,1), (6,0)]
|
|
(3,-2) (5, 1) (6, 0)
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (AP_i) to the next one (AP_i+1).
|
|
@param[in]
|
|
x device array pointing to the beginning of the first vector (x_1).
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[inout]
|
|
y device array pointing to the beginning of the first vector (y_1).
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hpr functions perform the matrix-vector operations:
|
|
|
|
A := A + alpha*x*x**H
|
|
|
|
where ``alpha`` is a real scalar, ``x`` is a vector, and ``A`` is an
|
|
``n`` by ``n`` Hermitian matrix, supplied in packed form.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : ``c`` and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of matrix A. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[inout]
|
|
AP device pointer storing the packed version of the specified triangular portion of
|
|
the Hermitian matrix A. Of at least size ((n * (n + 1)) / 2).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of the Hermitian matrix A is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of the Hermitian matrix A is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpr(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipComplex* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpr(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipDoubleComplex* AP);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpr_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipComplex* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpr_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipDoubleComplex* AP);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hprBatched functions perform the matrix-vector operations:
|
|
|
|
A_i := A_i + alpha*x_i*x_i**H
|
|
|
|
where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[inout]
|
|
AP device array of device pointers storing the packed version of the specified triangular portion of
|
|
each Hermitian matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at least size batchCount.
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- Note that the imaginary part of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChprBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
hipComplex* const AP[],
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhprBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
hipDoubleComplex* const AP[],
|
|
int batchCount);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChprBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
hipComplex* const AP[],
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhprBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
hipDoubleComplex* const AP[],
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hprStridedBatched functions perform the matrix-vector operations:
|
|
|
|
A_i := A_i + alpha*x_i*x_i**H
|
|
|
|
where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer pointing to the first vector (x_1).
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
@param[inout]
|
|
AP device array of device pointers storing the packed version of the specified triangular portion of
|
|
each Hermitian matrix A_i. Points to the first matrix (A_1).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one (A_i) to the next (A_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChprStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* AP,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhprStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChprStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipComplex* AP,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhprStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hpr2 functions perform the matrix-vector operations:
|
|
|
|
A := A + alpha*x*y**H + conj(alpha)*y*x**H
|
|
|
|
where ``alpha`` is a complex scalar, ``x`` and ``y`` are vectors, and ``A`` is an
|
|
``n`` by ``n`` Hermitian matrix, supplied in packed form.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : ``c`` and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of matrix A. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[inout]
|
|
AP device pointer storing the packed version of the specified triangular portion of
|
|
the Hermitian matrix A. Of at least size ((n * (n + 1)) / 2).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of the Hermitian matrix A is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of the Hermitian matrix A is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpr2(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipComplex* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpr2(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipDoubleComplex* AP);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpr2_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipComplex* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpr2_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipDoubleComplex* AP);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hpr2Batched functions perform the matrix-vector operations:
|
|
|
|
A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H
|
|
|
|
where ``alpha`` is a complex scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[inout]
|
|
AP device array of device pointers storing the packed version of the specified triangular portion of
|
|
each Hermitian matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at least size batchCount.
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- Note that the imaginary parts of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpr2Batched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* const y[],
|
|
int incy,
|
|
hipComplex* const AP[],
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpr2Batched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* const y[],
|
|
int incy,
|
|
hipDoubleComplex* const AP[],
|
|
int batchCount);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpr2Batched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* const y[],
|
|
int64_t incy,
|
|
hipComplex* const AP[],
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpr2Batched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
hipDoubleComplex* const AP[],
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The hpr2StridedBatched functions perform the matrix-vector operations:
|
|
|
|
A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H
|
|
|
|
where ``alpha`` is a complex scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer pointing to the first vector (x_1).
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
@param[in]
|
|
y device pointer pointing to the first vector (y_1).
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
@param[inout]
|
|
AP device array of device pointers storing the packed version of the specified triangular portion of
|
|
each Hermitian matrix A_i. Points to the first matrix (A_1).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each Hermitian matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3)
|
|
(1, 0) (2, 1) (4,9)
|
|
(2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)]
|
|
(4,-9) (5,-3) (6,0)
|
|
- Note that the imaginary part of the diagonal elements are not accessed and are assumed
|
|
to be 0.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one (A_i) to the next (A_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpr2StridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpr2StridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
//64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChpr2StridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhpr2StridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The sbmv functions perform the matrix-vector operation:
|
|
|
|
y := alpha*A*x + beta*y,
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n``-element vectors, and
|
|
``A`` should contain an upper or lower triangular ``n`` by ``n`` symmetric banded matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : ``s`` and ``d``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
@param[in]
|
|
k [int]
|
|
specifies the number of sub- and super-diagonals.
|
|
@param[in]
|
|
alpha
|
|
specifies the scalar alpha.
|
|
@param[in]
|
|
AP pointer storing matrix A on the GPU.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of matrix A.
|
|
@param[in]
|
|
x pointer storing vector x on the GPU.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
beta specifies the scalar beta.
|
|
@param[out]
|
|
y pointer storing vector y on the GPU.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsbmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
const float* x,
|
|
int incx,
|
|
const float* beta,
|
|
float* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsbmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
const double* x,
|
|
int incx,
|
|
const double* beta,
|
|
double* y,
|
|
int incy);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsbmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
const float* x,
|
|
int64_t incx,
|
|
const float* beta,
|
|
float* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsbmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
const double* x,
|
|
int64_t incx,
|
|
const double* beta,
|
|
double* y,
|
|
int64_t incy);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The sbmvBatched functions perform the matrix-vector operation:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i,
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric banded matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
``A`` should contain an upper or lower triangular ``n`` by ``n`` symmetric banded matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
number of rows and columns of each matrix A_i.
|
|
@param[in]
|
|
k [int]
|
|
specifies the number of sub- and super-diagonals.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each matrix A_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each vector x_i.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[out]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each vector y_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsbmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int lda,
|
|
const float* const x[],
|
|
int incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsbmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int lda,
|
|
const double* const x[],
|
|
int incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The sbmvStridedBatched functions perform the matrix-vector operation:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i,
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric banded matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
``A`` should contain an upper or lower triangular ``n`` by ``n`` symmetric banded matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
number of rows and columns of each matrix A_i.
|
|
@param[in]
|
|
k [int]
|
|
specifies the number of sub- and super-diagonals.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device pointer to the first matrix A_1 on the GPU.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each matrix A_i.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
@param[in]
|
|
x device pointer to the first vector x_1 on the GPU.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each vector x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stridex. However, the user should
|
|
ensure that stridex is of an appropriate size.
|
|
This typically means stridex >= n * incx. stridex should be non zero.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[out]
|
|
y device pointer to the first vector y_1 on the GPU.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each vector y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
There are no restrictions placed on stridey. However, the user should
|
|
ensure that stridey is of an appropriate size.
|
|
This typically means stridey >= n * incy. stridey should be non zero.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The spmv functions perform the matrix-vector operation:
|
|
|
|
y := alpha*A*x + beta*y,
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n``-element vectors, and
|
|
``A`` should contain an upper or lower triangular ``n`` by ``n`` packed symmetric matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : ``s`` and ``d``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
@param[in]
|
|
alpha
|
|
specifies the scalar alpha.
|
|
@param[in]
|
|
AP pointer storing matrix A on the GPU.
|
|
@param[in]
|
|
x pointer storing vector x on the GPU.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
beta specifies the scalar beta.
|
|
@param[out]
|
|
y pointer storing vector y on the GPU.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
const float* x,
|
|
int incx,
|
|
const float* beta,
|
|
float* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
const double* x,
|
|
int incx,
|
|
const double* beta,
|
|
double* y,
|
|
int incy);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
const float* x,
|
|
int64_t incx,
|
|
const float* beta,
|
|
float* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
const double* x,
|
|
int64_t incx,
|
|
const double* beta,
|
|
double* y,
|
|
int64_t incy);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The spmvBatched functions perform the matrix-vector operation:
|
|
|
|
y_i := alpha*AP_i*x_i + beta*y_i,
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
``A`` should contain an upper or lower triangular ``n`` by ``n`` packed symmetric matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
number of rows and columns of each matrix A_i.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each vector x_i.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[out]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each vector y_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
const float* const x[],
|
|
int incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
const double* const x[],
|
|
int incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
const float* const x[],
|
|
int64_t incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
const double* const x[],
|
|
int64_t incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The spmvStridedBatched functions perform the matrix-vector operation:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i,
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
``A`` should contain an upper or lower triangular ``n`` by ``n`` packed symmetric matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
number of rows and columns of each matrix A_i.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP Device pointer to the first matrix A_1 on the GPU.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
@param[in]
|
|
x Device pointer to the first vector x_1 on the GPU.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each vector x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stridex. However, the user should
|
|
take care to ensure that stridex is of an appropriate size.
|
|
This typically means stridex >= n * incx. stridex should be non zero.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[out]
|
|
y Device pointer to the first vector y_1 on the GPU.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each vector y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
There are no restrictions placed on stridey. However, the user should
|
|
take care to ensure that stridey is of an appropriate size.
|
|
This typically means stridey >= n * incy. stridey should be non zero.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The spr functions perform the matrix-vector operations:
|
|
|
|
A := A + alpha*x*x**T
|
|
|
|
where ``alpha`` is a scalar, ``x`` is a vector, and ``A`` is an
|
|
``n`` by ``n`` symmetric matrix, supplied in packed form.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of matrix A. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[inout]
|
|
AP device pointer storing the packed version of the specified triangular portion of
|
|
the symmetric matrix A. Of at least size ((n * (n + 1)) / 2).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of the symmetric matrix A is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4)
|
|
1 2 4 7
|
|
2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
4 5 6 9
|
|
7 8 9 0
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of the symmetric matrix A is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4)
|
|
1 2 3 4
|
|
2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
3 6 8 9
|
|
4 7 9 0
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspr(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
float* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspr(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
double* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCspr(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipComplex* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZspr(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipDoubleComplex* AP);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspr_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
float* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspr_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
double* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCspr_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipComplex* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZspr_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipDoubleComplex* AP);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The sprBatched functions perform the matrix-vector operations:
|
|
|
|
A_i := A_i + alpha*x_i*x_i**T
|
|
|
|
where ``alpha`` is a scalar, ``x_i`` is a vector, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[inout]
|
|
AP device array of device pointers storing the packed version of the specified triangular portion of
|
|
each symmetric matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at least size batchCount.
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each symmetric matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4)
|
|
1 2 4 7
|
|
2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
4 5 6 9
|
|
7 8 9 0
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each symmetric matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4)
|
|
1 2 3 4
|
|
2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
3 6 8 9
|
|
4 7 9 0
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsprBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int incx,
|
|
float* const AP[],
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsprBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int incx,
|
|
double* const AP[],
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsprBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
hipComplex* const AP[],
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsprBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
hipDoubleComplex* const AP[],
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsprBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
float* const AP[],
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsprBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
double* const AP[],
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsprBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
hipComplex* const AP[],
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsprBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
hipDoubleComplex* const AP[],
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The sprStridedBatched functions perform the matrix-vector operations:
|
|
|
|
A_i := A_i + alpha*x_i*x_i**T
|
|
|
|
where ``alpha`` is a scalar, ``x_i`` is a vector, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer pointing to the first vector (x_1).
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
@param[inout]
|
|
AP device pointer storing the packed version of the specified triangular portion of
|
|
each symmetric matrix A_i. Points to the first A_1.
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each symmetric matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4)
|
|
1 2 4 7
|
|
2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
4 5 6 9
|
|
7 8 9 0
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each symmetric matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(2) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4)
|
|
1 2 3 4
|
|
2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
3 6 8 9
|
|
4 7 9 0
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one (A_i) to the next (A_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsprStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
float* AP,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsprStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
double* AP,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsprStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* AP,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsprStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsprStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
float* AP,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsprStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
double* AP,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsprStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipComplex* AP,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsprStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The spr2 functions perform the matrix-vector operation:
|
|
|
|
A := A + alpha*x*y**T + alpha*y*x**T
|
|
|
|
where ``alpha`` is a scalar, ``x`` and ``y`` are vectors, and ``A`` is an
|
|
``n`` by ``n`` symmetric matrix, supplied in packed form.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : ``s`` and ``d``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of matrix A. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[inout]
|
|
AP device pointer storing the packed version of the specified triangular portion of
|
|
the symmetric matrix A. Of at least size ((n * (n + 1)) / 2).
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of the symmetric matrix A is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4)
|
|
1 2 4 7
|
|
2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
4 5 6 9
|
|
7 8 9 0
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of the symmetric matrix A is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(n) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4)
|
|
1 2 3 4
|
|
2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
3 6 8 9
|
|
4 7 9 0
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspr2(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
const float* y,
|
|
int incy,
|
|
float* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspr2(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
const double* y,
|
|
int incy,
|
|
double* AP);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspr2_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
const float* y,
|
|
int64_t incy,
|
|
float* AP);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspr2_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
const double* y,
|
|
int64_t incy,
|
|
double* AP);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The spr2Batched functions perform the matrix-vector operation:
|
|
|
|
A_i := A_i + alpha*x_i*y_i**T + alpha*y_i*x_i**T
|
|
|
|
where ``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[inout]
|
|
AP device array of device pointers storing the packed version of the specified triangular portion of
|
|
each symmetric matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at least size batchCount.
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each symmetric matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4)
|
|
1 2 4 7
|
|
2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
4 5 6 9
|
|
7 8 9 0
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each symmetric matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(n) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4)
|
|
1 2 3 4
|
|
2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
3 6 8 9
|
|
4 7 9 0
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspr2Batched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int incx,
|
|
const float* const y[],
|
|
int incy,
|
|
float* const AP[],
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspr2Batched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int incx,
|
|
const double* const y[],
|
|
int incy,
|
|
double* const AP[],
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspr2Batched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
const float* const y[],
|
|
int64_t incy,
|
|
float* const AP[],
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspr2Batched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
const double* const y[],
|
|
int64_t incy,
|
|
double* const AP[],
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The spr2StridedBatched functions perform the matrix-vector operation:
|
|
|
|
A_i := A_i + alpha*x_i*y_i**T + alpha*y_i*x_i**T
|
|
|
|
where ``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s`` and ``d``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in AP.
|
|
- HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in AP.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A_i. Must be at least 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer pointing to the first vector (x_1).
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
@param[in]
|
|
y device pointer pointing to the first vector (y_1).
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
@param[inout]
|
|
AP device pointer storing the packed version of the specified triangular portion of
|
|
each symmetric matrix A_i. Points to the first A_1.
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The upper triangular portion of each symmetric matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(0,1)
|
|
AP(2) = A(1,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4)
|
|
1 2 4 7
|
|
2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
4 5 6 9
|
|
7 8 9 0
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The lower triangular portion of each symmetric matrix A_i is supplied.
|
|
The matrix is compacted so that AP contains the triangular portion column-by-column
|
|
so that:
|
|
AP(0) = A(0,0)
|
|
AP(1) = A(1,0)
|
|
AP(n) = A(2,1), and so forth.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4)
|
|
1 2 3 4
|
|
2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
|
|
3 6 8 9
|
|
4 7 9 0
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one (A_i) to the next (A_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspr2StridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
float* AP,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspr2StridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
double* AP,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSspr2StridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
float* AP,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDspr2StridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
double* AP,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The symv functions perform the matrix-vector operation:
|
|
|
|
y := alpha*A*x + beta*y,
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n``-element vectors, and
|
|
``A`` should contain an upper or lower triangular ``n`` by ``n`` symmetric matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
@param[in]
|
|
alpha
|
|
specifies the scalar alpha.
|
|
@param[in]
|
|
AP pointer storing matrix A on the GPU.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
@param[in]
|
|
x pointer storing vector x on the GPU.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
beta specifies the scalar beta.
|
|
@param[out]
|
|
y pointer storing vector y on the GPU.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
const float* x,
|
|
int incx,
|
|
const float* beta,
|
|
float* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
const double* x,
|
|
int incx,
|
|
const double* beta,
|
|
double* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
const float* x,
|
|
int64_t incx,
|
|
const float* beta,
|
|
float* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
const double* x,
|
|
int64_t incx,
|
|
const double* beta,
|
|
double* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
symvBatched performs the matrix-vector operation:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i,
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
n by n symmetric matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
``A`` should contain an upper or lower triangular symmetric matrix.
|
|
The opposing triangular part of ``A`` is not referenced.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
number of rows and columns of each matrix A_i.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each matrix A_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each vector x_i.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[out]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each vector y_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int lda,
|
|
const float* const x[],
|
|
int incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int lda,
|
|
const double* const x[],
|
|
int incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int incy,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The symvStridedBatched functions perform the matrix-vector operation:
|
|
|
|
y_i := alpha*A_i*x_i + beta*y_i,
|
|
|
|
where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch,
|
|
``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
``A`` should contain an upper or lower triangular symmetric matrix.
|
|
The opposing triangular part of A is not referenced
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
number of rows and columns of each matrix A_i.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
AP Device pointer to the first matrix A_1 on the GPU.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each matrix A_i.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
@param[in]
|
|
x Device pointer to the first vector x_1 on the GPU.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each vector x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stridex. However, the user should
|
|
take care to ensure that stridex is of an appropriate size.
|
|
This typically means stridex >= n * incx. stridex should be non zero.
|
|
@param[in]
|
|
beta device pointer or host pointer to scalar beta.
|
|
@param[out]
|
|
y Device pointer to the first vector y_1 on the GPU.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each vector y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
There are no restrictions placed on stridey. However, the user should
|
|
take care to ensure that stridey is of an appropriate size.
|
|
This typically means stridey >= n * incy. stridey should be non zero.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The syr functions perform the matrix-vector operations:
|
|
|
|
A := A + alpha*x*x**T
|
|
|
|
where ``alpha`` is a scalar, ``x`` is a vector, and ``A`` is an
|
|
``n`` by ``n`` symmetric matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of matrix A.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[inout]
|
|
AP device pointer storing matrix A.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
float* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
double* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipComplex* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipDoubleComplex* AP,
|
|
int lda);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
float* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
double* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipComplex* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The syrBatched functions perform a batch of matrix-vector operations:
|
|
|
|
A[i] := A[i] + alpha*x[i]*x[i]**T
|
|
|
|
where ``alpha`` is a scalar, ``x`` is an array of vectors, and ``A`` is an array of
|
|
``n`` by ``n`` symmetric matrices, for ``i`` = 1 , ... , ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of matrix A.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[inout]
|
|
AP device array of device pointers storing each matrix A_i.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int incx,
|
|
float* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int incx,
|
|
double* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
hipComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
hipDoubleComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
float* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
double* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
hipComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The syrStridedBatched functions perform the matrix-vector operations:
|
|
|
|
A[i] := A[i] + alpha*x[i]*x[i]**T
|
|
|
|
where ``alpha`` is a scalar, ``x`` is a pointer to an array of vectors, and ``A`` is an array of
|
|
``n`` by ``n`` symmetric matrices, for ``i`` = 1 , ... , ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
specifies the pointer increment between vectors (x_i) and (x_i+1).
|
|
@param[inout]
|
|
AP device pointer to the first matrix A_1.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The syr2 functions perform the matrix-vector operations:
|
|
|
|
A := A + alpha*x*y**T + alpha*y*x**T
|
|
|
|
where ``alpha`` is a scalar, ``x`` and ``y`` are vectors, and ``A`` is an
|
|
``n`` by ``n`` symmetric matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of matrix A.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[inout]
|
|
AP device pointer storing matrix A.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
const float* y,
|
|
int incy,
|
|
float* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
const double* y,
|
|
int incy,
|
|
double* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipComplex* AP,
|
|
int lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipDoubleComplex* AP,
|
|
int lda);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
const float* y,
|
|
int64_t incy,
|
|
float* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
const double* y,
|
|
int64_t incy,
|
|
double* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipComplex* AP,
|
|
int64_t lda);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The syr2Batched functions perform a batch of matrix-vector operations:
|
|
|
|
A[i] := A[i] + alpha*x[i]*y[i]**T + alpha*y[i]*x[i]**T
|
|
|
|
where ``alpha`` is a scalar, ``x[i]`` and ``y[i]`` are vectors, and ``A[i]`` is an
|
|
``n`` by ``n`` symmetric matrix, for ``i`` = 1 , ... , ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of matrix A.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[inout]
|
|
AP device array of device pointers storing each matrix A_i.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2Batched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int incx,
|
|
const float* const y[],
|
|
int incy,
|
|
float* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2Batched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int incx,
|
|
const double* const y[],
|
|
int incy,
|
|
double* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2Batched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
const hipComplex* const y[],
|
|
int incy,
|
|
hipComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2Batched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
const hipDoubleComplex* const y[],
|
|
int incy,
|
|
hipDoubleComplex* const AP[],
|
|
int lda,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2Batched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
const float* const y[],
|
|
int64_t incy,
|
|
float* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2Batched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
const double* const y[],
|
|
int64_t incy,
|
|
double* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2Batched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
const hipComplex* const y[],
|
|
int64_t incy,
|
|
hipComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2Batched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
const hipDoubleComplex* const y[],
|
|
int64_t incy,
|
|
hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The syr2StridedBatched functions perform the matrix-vector operations:
|
|
|
|
A[i] := A[i] + alpha*x[i]*y[i]**T + alpha*y[i]*x[i]**T
|
|
|
|
where ``alpha`` is a scalar, ``x[i]`` and ``y[i]`` are vectors, and ``A[i]`` is an
|
|
``n`` by ``n`` symmetric matrices, for ``i`` = 1 , ... , ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of each matrix A.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer to scalar alpha.
|
|
@param[in]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
specifies the pointer increment between vectors (x_i) and (x_i+1).
|
|
@param[in]
|
|
y device pointer to the first vector y_1.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
specifies the pointer increment between vectors (y_i) and (y_i+1).
|
|
@param[inout]
|
|
AP device pointer to the first matrix A_1.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2StridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2StridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2StridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2StridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2StridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2StridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2StridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2StridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief BLAS Level 2 API
|
|
|
|
\details
|
|
The tbmv functions perform one of the matrix-vector operations:
|
|
|
|
x := A*x or
|
|
x := A**T*x or
|
|
x := A**H*x,
|
|
|
|
where ``x`` is a vector and ``A`` is a banded ``n`` by ``n`` matrix (see description below).
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper banded triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower banded triangular matrix.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
indicates whether matrix A is tranposed (conjugated) or not.
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: The main diagonal of A is assumed to consist of only
|
|
1's and is not referenced.
|
|
- HIPBLAS_DIAG_NON_UNIT: No assumptions are made of A's main diagonal.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of the matrix represented by A.
|
|
@param[in]
|
|
k [int]
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER, k specifies the number of super-diagonals
|
|
of the matrix A.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER, k specifies the number of sub-diagonals
|
|
of the matrix A.
|
|
- k must satisfy k > 0 && k < lda.
|
|
@param[in]
|
|
AP device pointer storing banded triangular matrix A.
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The matrix represented is an upper banded triangular matrix
|
|
with the main diagonal and k super-diagonals. Everything
|
|
else can be assumed to be 0.
|
|
The matrix is compacted so that the main diagonal resides on the k'th
|
|
row, the first super diagonal resides on the RHS of the k-1'th row, and so forth,
|
|
with the k'th diagonal on the RHS of the 0'th row.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 5; k = 2)
|
|
1 6 9 0 0 -> 0 0 9 8 7
|
|
0 2 7 8 0 -> 0 6 7 8 9
|
|
0 0 3 8 7 -> 1 2 3 4 5
|
|
0 0 0 4 9 -> 0 0 0 0 0
|
|
0 0 0 0 5 -> 0 0 0 0 0
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The matrix represnted is a lower banded triangular matrix
|
|
with the main diagonal and k sub-diagonals. Everything else can be
|
|
assumed to be 0.
|
|
The matrix is compacted so that the main diagonal resides on the 0'th row,
|
|
working up to the k'th diagonal residing on the LHS of the k'th row.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 5; k = 2)
|
|
1 0 0 0 0 -> 1 2 3 4 5
|
|
6 2 0 0 0 -> 6 7 8 9 0
|
|
9 7 3 0 0 -> 9 8 7 0 0
|
|
0 8 8 4 0 -> 0 0 0 0 0
|
|
0 0 7 9 5 -> 0 0 0 0 0
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A. lda must satisfy lda > k.
|
|
@param[inout]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const float* AP,
|
|
int lda,
|
|
float* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const double* AP,
|
|
int lda,
|
|
double* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipComplex* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipDoubleComplex* x,
|
|
int incx);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* AP,
|
|
int64_t lda,
|
|
float* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* AP,
|
|
int64_t lda,
|
|
double* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipComplex* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipDoubleComplex* x,
|
|
int64_t incx);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The tbmvBatched functions perform one of the matrix-vector operations:
|
|
|
|
x_i := A_i*x_i or
|
|
x_i := A_i**T*x_i or
|
|
x_i := A_i**H*x_i,
|
|
|
|
where ``(A_i, x_i)`` is the ``i``-th instance of the batch,
|
|
``x_i`` is a vector, and ``A_i`` is an ``n`` by ``n`` matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: each A_i is an upper banded triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: each A_i is a lower banded triangular matrix.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
indicates whether each matrix A_i is tranposed (conjugated) or not.
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: The main diagonal of each A_i is assumed to consist of only
|
|
1's and is not referenced.
|
|
- HIPBLAS_DIAG_NON_UNIT: No assumptions are made of each A_i's main diagonal.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of the matrix represented by each A_i.
|
|
@param[in]
|
|
k [int]
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER, k specifies the number of super-diagonals
|
|
of each matrix A_i.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER, k specifies the number of sub-diagonals
|
|
of each matrix A_i.
|
|
- k must satisfy k > 0 && k < lda.
|
|
@param[in]
|
|
AP device array of device pointers storing each banded triangular matrix A_i.
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The matrix represented is an upper banded triangular matrix
|
|
with the main diagonal and k super-diagonals. Everything
|
|
else can be assumed to be 0.
|
|
The matrix is compacted so that the main diagonal resides on the k'th
|
|
row, the first super diagonal resides on the RHS of the k-1'th row, and so forth,
|
|
with the k'th diagonal on the RHS of the 0'th row.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 5; k = 2)
|
|
1 6 9 0 0 -> 0 0 9 8 7
|
|
0 2 7 8 0 -> 0 6 7 8 9
|
|
0 0 3 8 7 -> 1 2 3 4 5
|
|
0 0 0 4 9 -> 0 0 0 0 0
|
|
0 0 0 0 5 -> 0 0 0 0 0
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The matrix represnted is a lower banded triangular matrix
|
|
with the main diagonal and k sub-diagonals. Everything else can be
|
|
assumed to be 0.
|
|
The matrix is compacted so that the main diagonal resides on the 0'th row,
|
|
working up to the k'th diagonal residing on the LHS of the k'th row.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 5; k = 2)
|
|
1 0 0 0 0 -> 1 2 3 4 5
|
|
6 2 0 0 0 -> 6 7 8 9 0
|
|
9 7 3 0 0 -> 9 8 7 0 0
|
|
0 8 8 4 0 -> 0 0 0 0 0
|
|
0 0 7 9 5 -> 0 0 0 0 0
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i. lda must satisfy lda > k.
|
|
@param[inout]
|
|
x device array of device pointer storing each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const float* const AP[],
|
|
int lda,
|
|
float* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const double* const AP[],
|
|
int lda,
|
|
double* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
hipComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
float* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
double* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The tbmvStridedBatched functions perform one of the matrix-vector operations:
|
|
|
|
x_i := A_i*x_i or
|
|
x_i := A_i**T*x_i or
|
|
x_i := A_i**H*x_i,
|
|
|
|
where ``(A_i, x_i)`` is the ``i``-th instance of the batch,
|
|
``x_i`` is a vector, and ``A_i`` is an ``n`` by ``n`` matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: each A_i is an upper banded triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: each A_i is a lower banded triangular matrix.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
indicates whether each matrix A_i is tranposed (conjugated) or not.
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: The main diagonal of each A_i is assumed to consist of only
|
|
1's and is not referenced.
|
|
- HIPBLAS_DIAG_NON_UNIT: No assumptions are made of each A_i's main diagonal.
|
|
@param[in]
|
|
n [int]
|
|
the number of rows and columns of the matrix represented by each A_i.
|
|
@param[in]
|
|
k [int]
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER, k specifies the number of super-diagonals
|
|
of each matrix A_i.
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER, k specifies the number of sub-diagonals
|
|
of each matrix A_i.
|
|
- k must satisfy k > 0 && k < lda.
|
|
@param[in]
|
|
AP device array to the first matrix A_i of the batch. Stores each banded triangular matrix A_i.
|
|
- if uplo == HIPBLAS_FILL_MODE_UPPER:
|
|
The matrix represented is an upper banded triangular matrix
|
|
with the main diagonal and k super-diagonals. Everything
|
|
else can be assumed to be 0.
|
|
The matrix is compacted so that the main diagonal resides on the k'th
|
|
row, the first super diagonal resides on the RHS of the k-1'th row, and so forth,
|
|
with the k'th diagonal on the RHS of the 0'th row.
|
|
Ex: (HIPBLAS_FILL_MODE_UPPER; n = 5; k = 2)
|
|
1 6 9 0 0 -> 0 0 9 8 7
|
|
0 2 7 8 0 -> 0 6 7 8 9
|
|
0 0 3 8 7 -> 1 2 3 4 5
|
|
0 0 0 4 9 -> 0 0 0 0 0
|
|
0 0 0 0 5 -> 0 0 0 0 0
|
|
- if uplo == HIPBLAS_FILL_MODE_LOWER:
|
|
The matrix represnted is a lower banded triangular matrix
|
|
with the main diagonal and k sub-diagonals. Everything else can be
|
|
assumed to be 0.
|
|
The matrix is compacted so that the main diagonal resides on the 0'th row,
|
|
working up to the k'th diagonal residing on the LHS of the k'th row.
|
|
Ex: (HIPBLAS_FILL_MODE_LOWER; n = 5; k = 2)
|
|
1 0 0 0 0 -> 1 2 3 4 5
|
|
6 2 0 0 0 -> 6 7 8 9 0
|
|
9 7 3 0 0 -> 9 8 7 0 0
|
|
0 8 8 4 0 -> 0 0 0 0 0
|
|
0 0 7 9 5 -> 0 0 0 0 0
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i. lda must satisfy lda > k.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one A_i matrix to the next A_(i + 1).
|
|
@param[inout]
|
|
x device array to the first vector x_i of the batch.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one x_i matrix to the next x_(i + 1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The tbsv functions solve:
|
|
|
|
A*x = b or A**T*x = b or A**H*x = b,
|
|
|
|
where ``x`` and ``b`` are vectors and ``A`` is a banded triangular matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: Solves A*x = b
|
|
- HIPBLAS_OP_T: Solves A**T*x = b
|
|
- HIPBLAS_OP_C: Solves A**H*x = b
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular (that is, the diagonal elements
|
|
of A are not used in computations).
|
|
- HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of b. n >= 0.
|
|
@param[in]
|
|
k [int]
|
|
- if(uplo == HIPBLAS_FILL_MODE_UPPER),
|
|
k specifies the number of super-diagonals of A.
|
|
- if(uplo == HIPBLAS_FILL_MODE_LOWER),
|
|
k specifies the number of sub-diagonals of A.
|
|
- k >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer storing the matrix A in banded format.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
lda >= (k + 1).
|
|
|
|
@param[inout]
|
|
x device pointer storing input vector b. Overwritten by the output vector x.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const float* AP,
|
|
int lda,
|
|
float* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const double* AP,
|
|
int lda,
|
|
double* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipComplex* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipDoubleComplex* x,
|
|
int incx);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* AP,
|
|
int64_t lda,
|
|
float* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* AP,
|
|
int64_t lda,
|
|
double* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipComplex* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipDoubleComplex* x,
|
|
int64_t incx);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The tbsvBatched functions solve:
|
|
|
|
A_i*x_i = b_i or A_i**T*x_i = b_i or A_i**H*x_i = b_i,
|
|
|
|
where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a banded triangular matrix,
|
|
for ``i`` = [1, ``batchCount``].
|
|
|
|
The input vectors ``b_i`` are overwritten by the output vectors ``x_i``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: Solves A_i*x_i = b_i
|
|
- HIPBLAS_OP_T: Solves A_i**T*x_i = b_i
|
|
- HIPBLAS_OP_C: Solves A_i**H*x_i = b_i
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular (that is, the diagonal elements
|
|
of each A_i are not used in computations).
|
|
- HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of each b_i. n >= 0.
|
|
@param[in]
|
|
k [int]
|
|
- if(uplo == HIPBLAS_FILL_MODE_UPPER),
|
|
k specifies the number of super-diagonals of each A_i.
|
|
- if(uplo == HIPBLAS_FILL_MODE_LOWER),
|
|
k specifies the number of sub-diagonals of each A_i.
|
|
- k >= 0.
|
|
|
|
@param[in]
|
|
AP device vector of device pointers storing each matrix A_i in banded format.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
lda >= (k + 1).
|
|
|
|
@param[inout]
|
|
x device vector of device pointers storing each input vector b_i. Overwritten by each output
|
|
vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const float* const AP[],
|
|
int lda,
|
|
float* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const double* const AP[],
|
|
int lda,
|
|
double* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
hipComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
float* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
double* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The tbsvStridedBatched functions solve:
|
|
|
|
A_i*x_i = b_i or A_i**T*x_i = b_i or A_i**H*x_i = b_i,
|
|
|
|
where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a banded triangular matrix,
|
|
for ``i`` = [1, ``batchCount``].
|
|
|
|
The input vectors ``b_i`` are overwritten by the output vectors ``x_i``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: Solves A_i*x_i = b_i
|
|
- HIPBLAS_OP_T: Solves A_i**T*x_i = b_i
|
|
- HIPBLAS_OP_C: Solves A_i**H*x_i = b_i
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular (that is, the diagonal elements
|
|
of each A_i are not used in computations).
|
|
- HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of each b_i. n >= 0.
|
|
@param[in]
|
|
k [int]
|
|
- if(uplo == HIPBLAS_FILL_MODE_UPPER),
|
|
k specifies the number of super-diagonals of each A_i.
|
|
- if(uplo == HIPBLAS_FILL_MODE_LOWER),
|
|
k specifies the number of sub-diagonals of each A_i.
|
|
- k >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer pointing to the first banded matrix A_1.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
lda >= (k + 1).
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
specifies the distance between the start of one matrix (A_i) and the next (A_i+1).
|
|
|
|
@param[inout]
|
|
x device pointer pointing to the first input vector b_1. Overwritten by output vectors x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
specifies the distance between the start of one vector (x_i) and the next (x_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStbsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtbsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtbsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtbsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The tpmv functions perform one of the matrix-vector operations:
|
|
|
|
x = A*x or x = A**T*x,
|
|
|
|
where ``x`` is an ``n``-element vector and ``A`` is an ``n`` by ``n`` unit, or non-unit, upper or lower triangular matrix, supplied in the pack form.
|
|
|
|
The vector ``x`` is overwritten.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of A. n >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer storing matrix A,
|
|
of dimension at least ( n * ( n + 1 ) / 2 ).
|
|
- Before entry with uplo = HIPBLAS_FILL_MODE_UPPER, the array A
|
|
must contain the upper triangular matrix packed sequentially,
|
|
column by column, so that A[0] contains a_{0,0}, A[1] and A[2] contain
|
|
a_{0,1} and a_{1, 1} respectively, and so on.
|
|
- Before entry with uplo = HIPBLAS_FILL_MODE_LOWER, the array A
|
|
must contain the lower triangular matrix packed sequentially,
|
|
column by column, so that A[0] contains a_{0,0}, A[1] and A[2] contain
|
|
a_{1,0} and a_{2,0} respectively, and so on.
|
|
- Note that when DIAG = HIPBLAS_DIAG_UNIT, the diagonal elements of A are
|
|
not referenced, but are assumed to be unity.
|
|
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x. incx must not be zero.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* AP,
|
|
float* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* AP,
|
|
double* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* AP,
|
|
hipComplex* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
hipDoubleComplex* x,
|
|
int incx);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* AP,
|
|
float* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* AP,
|
|
double* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* AP,
|
|
hipComplex* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* AP,
|
|
hipDoubleComplex* x,
|
|
int64_t incx);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The tpmvBatched functions perform one of the matrix-vector operations:
|
|
|
|
x_i = A_i*x_i or x_i = A**T*x_i, 0 \le i < batchCount
|
|
|
|
where ``x_i`` is an ``n``-element vector and ``A_i`` is an ``n`` by ``n`` (unit, or non-unit, upper or lower triangular matrix).
|
|
|
|
The vectors ``x_i`` are overwritten.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of matrices A_i. n >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer storing pointer of matrices A_i
|
|
of dimension ( lda, n ).
|
|
|
|
@param[in]
|
|
x device pointer storing vectors x_i.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of vectors x_i.
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
The number of batched matrices/vectors.
|
|
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* const AP[],
|
|
float* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* const AP[],
|
|
double* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* const AP[],
|
|
hipComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* const AP[],
|
|
hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* const AP[],
|
|
float* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* const AP[],
|
|
double* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* const AP[],
|
|
hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* const AP[],
|
|
hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The tpmvStridedBatched functions perform one of the matrix-vector operations:
|
|
|
|
x_i = A_i*x_i or x_i = A**T*x_i, 0 \le i < batchCount
|
|
|
|
where ``x_i`` is an n element vector and ``A_i`` is an ``n`` by ``n`` (unit, or non-unit, upper or lower triangular matrix),
|
|
with strides specifying how to retrieve ``$x_i$`` (resp. ``$A_i$``) from ``$x_{i-1}$`` (resp. ``$A_i$``).
|
|
|
|
The vectors ``x_i`` are overwritten.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of matrices A_i. n >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer of the matrix A_0
|
|
of dimension ( lda, n ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one A_i matrix to the next A_{i + 1}.
|
|
|
|
@param[in]
|
|
x device pointer storing the vector x_0.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of one vector x.
|
|
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one x_i vector to the next x_{i + 1}.
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
The number of batched matrices/vectors.
|
|
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* AP,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* AP,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* AP,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* AP,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* AP,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* AP,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The tpsv functions solve:
|
|
|
|
A*x = b or A**T*x = b, or A**H*x = b,
|
|
|
|
where ``x`` and ``b`` are vectors and ``A`` is a triangular matrix stored in the packed format.
|
|
|
|
The input vector ``b`` is overwritten by the output vector ``x``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: Solves A*x = b
|
|
- HIPBLAS_OP_T: Solves A**T*x = b
|
|
- HIPBLAS_OP_C: Solves A**H*x = b
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular (that is, the diagonal elements
|
|
of A are not used in computations).
|
|
- HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of b. n >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer storing the packed version of matrix A
|
|
of dimension >= (n * (n + 1) / 2).
|
|
|
|
@param[inout]
|
|
x device pointer storing vector b on input, overwritten by x on output.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* AP,
|
|
float* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* AP,
|
|
double* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* AP,
|
|
hipComplex* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
hipDoubleComplex* x,
|
|
int incx);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* AP,
|
|
float* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* AP,
|
|
double* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* AP,
|
|
hipComplex* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* AP,
|
|
hipDoubleComplex* x,
|
|
int64_t incx);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The tpsvBatched functions solve:
|
|
|
|
A_i*x_i = b_i or A_i**T*x_i = b_i, or A_i**H*x_i = b_i,
|
|
|
|
where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a triangular matrix stored in the packed format,
|
|
for ``i`` in [1, ``batchCount``].
|
|
|
|
The input vectors ``b_i`` are overwritten by the output vectors ``x_i``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: Solves A*x = b
|
|
- HIPBLAS_OP_T: Solves A**T*x = b
|
|
- HIPBLAS_OP_C: Solves A**H*x = b
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular (that is, the diagonal elements
|
|
of each A_i are not used in computations).
|
|
- HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of each b_i. n >= 0.
|
|
|
|
@param[in]
|
|
AP device array of device pointers storing the packed versions of each matrix A_i
|
|
of dimension >= (n * (n + 1) / 2).
|
|
|
|
@param[inout]
|
|
x device array of device pointers storing each input vector b_i, overwritten by x_i on output.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
specifies the number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* const AP[],
|
|
float* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* const AP[],
|
|
double* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* const AP[],
|
|
hipComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* const AP[],
|
|
hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* const AP[],
|
|
float* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* const AP[],
|
|
double* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* const AP[],
|
|
hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* const AP[],
|
|
hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The tpsvStridedBatched functions solve:
|
|
|
|
A_i*x_i = b_i or A_i**T*x_i = b_i, or A_i**H*x_i = b_i,
|
|
|
|
where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a triangular matrix stored in the packed format,
|
|
for ``i`` in [1, ``batchCount``].
|
|
|
|
The input vectors ``b_i`` are overwritten by the output vectors ``x_i``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: Solves A*x = b
|
|
- HIPBLAS_OP_T: Solves A**T*x = b
|
|
- HIPBLAS_OP_C: Solves A**H*x = b
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular (that is, the diagonal elements
|
|
of each A_i are not used in computations).
|
|
- HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of each b_i. n >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer pointing to the first packed matrix A_1
|
|
of dimension >= (n * (n + 1) / 2).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the beginning of one packed matrix (AP_i) to the next (AP_i+1).
|
|
|
|
@param[inout]
|
|
x device pointer pointing to the first input vector b_1. Overwritten by each x_i on output.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the beginning of one vector (x_i) to the next (x_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
specifies the number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* AP,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* AP,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* AP,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStpsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* AP,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtpsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* AP,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtpsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* AP,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtpsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* AP,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The trmv functions perform one of the matrix-vector operations:
|
|
|
|
x = A*x or x = A**T*x,
|
|
|
|
where ``x`` is an ``n``-element vector and ``A`` is an ``n`` by ``n`` unit, or non-unit, upper or lower triangular matrix.
|
|
|
|
The vector ``x`` is overwritten.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of A. n >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer storing matrix A,
|
|
of dimension ( lda, n ).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
lda = max( 1, n ).
|
|
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* AP,
|
|
int lda,
|
|
float* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* AP,
|
|
int lda,
|
|
double* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipComplex* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipDoubleComplex* x,
|
|
int incx);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* AP,
|
|
int64_t lda,
|
|
float* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* AP,
|
|
int64_t lda,
|
|
double* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipComplex* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipDoubleComplex* x,
|
|
int64_t incx);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The trmvBatched functions perform one of the matrix-vector operations:
|
|
|
|
x_i = A_i*x_i or x_i = A**T*x_i, 0 \le i < batchCount
|
|
|
|
where ``x_i`` is an ``n``-element vector and ``A_i`` is an ``n`` by ``n`` (unit, or non-unit, upper or lower triangular) matrix.
|
|
|
|
The vectors ``x_i`` are overwritten.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of matrices A_i. n >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer storing pointer of matrices A_i,
|
|
of dimension ( lda, n ).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A_i.
|
|
lda >= max( 1, n ).
|
|
|
|
@param[in]
|
|
x device pointer storing vectors x_i.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of vectors x_i.
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
The number of batched matrices/vectors.
|
|
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* const AP[],
|
|
int lda,
|
|
float* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* const AP[],
|
|
int lda,
|
|
double* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
hipComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
float* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
double* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The trmvStridedBatched functions perform one of the matrix-vector operations:
|
|
|
|
x_i = A_i*x_i or x_i = A**T*x_i, 0 \le i < batchCount
|
|
|
|
where ``x_i``is an ``n``-element vector and ``A_i`` is an ``n`` by ``n`` (unit, or non-unit, upper or lower triangular) matrix,
|
|
with strides specifying how to retrieve ``$x_i$`` (resp. ``$A_i$``) from ``$x_{i-1}$`` (resp. ``$A_i$``).
|
|
|
|
The vectors ``x_i`` are overwritten.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of matrices A_i. n >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer of the matrix A_0,
|
|
of dimension ( lda, n ).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A_i.
|
|
lda >= max( 1, n ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one A_i matrix to the next A_{i + 1}.
|
|
|
|
@param[in]
|
|
x device pointer storing the vector x_0.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of one vector x.
|
|
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one x_i vector to the next x_{i + 1}.
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
The number of batched matrices/vectors.
|
|
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The trsv functions solve:
|
|
|
|
A*x = b or A**T*x = b,
|
|
|
|
where ``x`` and ``b`` are vectors and ``A`` is a triangular matrix.
|
|
|
|
The vector ``x`` is overwritten on ``b``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of b. n >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer storing matrix A,
|
|
of dimension ( lda, n ).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
lda = max( 1, n ).
|
|
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* AP,
|
|
int lda,
|
|
float* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* AP,
|
|
int lda,
|
|
double* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipComplex* x,
|
|
int incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsv(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipDoubleComplex* x,
|
|
int incx);
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* AP,
|
|
int64_t lda,
|
|
float* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* AP,
|
|
int64_t lda,
|
|
double* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipComplex* x,
|
|
int64_t incx);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsv_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipDoubleComplex* x,
|
|
int64_t incx);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The trsvBatched functions solve:
|
|
|
|
A_i*x_i = b_i or A_i**T*x_i = b_i,
|
|
|
|
where ``(A_i, x_i, b_i)`` is the ``i``-th instance of the batch,
|
|
``x_i`` and ``b_i`` are vectors, and ``A_i`` is an
|
|
``n`` by ``n`` triangular matrix.
|
|
|
|
The vector ``x`` is overwritten on ``b``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of b. n >= 0.
|
|
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
lda = max(1, n).
|
|
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* const AP[],
|
|
int lda,
|
|
float* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* const AP[],
|
|
int lda,
|
|
double* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
hipComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsvBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
hipDoubleComplex* const x[],
|
|
int incx,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
float* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
double* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
hipComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsvBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 2 API </b>
|
|
|
|
\details
|
|
The trsvStridedBatched functions solve:
|
|
|
|
A_i*x_i = b_i or A_i**T*x_i = b_i,
|
|
|
|
where ``(A_i, x_i, b_i)`` is the ``i``-th instance of the batch,
|
|
``x_i`` and ``b_i`` are vectors, and ``A_i`` is an ``n`` by ``n`` triangular matrix, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
The vector ``x`` is overwritten on ``b``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of each b_i. n >= 0.
|
|
|
|
@param[in]
|
|
AP device pointer to the first matrix (A_1) in the batch, of dimension ( lda, n ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one A_i matrix to the next A_(i + 1).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
lda = max( 1, n ).
|
|
|
|
@param[in, out]
|
|
x device pointer to the first vector (x_1) in the batch.
|
|
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one x_i vector to the next x_(i + 1).
|
|
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsvStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsvStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t n,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*
|
|
* ===========================================================================
|
|
* level 3 BLAS
|
|
* ===========================================================================
|
|
*/
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The gemm functions perform one of the matrix-matrix operations:
|
|
|
|
C = alpha*op( A )*op( B ) + beta*C,
|
|
|
|
where op( X ) is one of:
|
|
|
|
op( X ) = X or
|
|
op( X ) = X**T or
|
|
op( X ) = X**H,
|
|
|
|
``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are matrices, with
|
|
``op( A )`` an ``m`` by ``k`` matrix, ``op( B )`` a ``k`` by ``n`` matrix, and ``C`` an ``m`` by ``n`` matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
specifies the form of op( A ).
|
|
@param[in]
|
|
transB [hipblasOperation_t]
|
|
specifies the form of op( B ).
|
|
@param[in]
|
|
m [int]
|
|
number or rows of matrices op( A ) and C.
|
|
@param[in]
|
|
n [int]
|
|
number of columns of matrices op( B ) and C.
|
|
@param[in]
|
|
k [int]
|
|
number of columns of matrix op( A ) and number of rows of matrix op( B ).
|
|
@param[in]
|
|
alpha device pointer or host pointer specifying the scalar alpha.
|
|
@param[in]
|
|
AP device pointer storing matrix A.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
@param[in]
|
|
BP device pointer storing matrix B.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of B.
|
|
@param[in]
|
|
beta device pointer or host pointer specifying the scalar beta.
|
|
@param[in, out]
|
|
CP device pointer storing matrix C on the GPU.
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of C.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHgemm(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* AP,
|
|
int lda,
|
|
const hipblasHalf* BP,
|
|
int ldb,
|
|
const hipblasHalf* beta,
|
|
hipblasHalf* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemm(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
const float* BP,
|
|
int ldb,
|
|
const float* beta,
|
|
float* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemm(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
const double* BP,
|
|
int ldb,
|
|
const double* beta,
|
|
double* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemm(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemm(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHgemm_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* AP,
|
|
int64_t lda,
|
|
const hipblasHalf* BP,
|
|
int64_t ldb,
|
|
const hipblasHalf* beta,
|
|
hipblasHalf* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemm_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
const float* BP,
|
|
int64_t ldb,
|
|
const float* beta,
|
|
float* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemm_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
const double* BP,
|
|
int64_t ldb,
|
|
const double* beta,
|
|
double* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemm_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemm_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The gemmBatched functions perform one of the batched matrix-matrix operations:
|
|
|
|
C_i = alpha*op( A_i )*op( B_i ) + beta*C_i, for i = 1, ..., batchCount.
|
|
|
|
where ``op( X )`` is one of:
|
|
|
|
op( X ) = X or
|
|
op( X ) = X**T or
|
|
op( X ) = X**H,
|
|
|
|
``alpha`` and ``beta`` are scalars, and ``A``, ``B`` , and ``C`` are strided batched matrices, with
|
|
``op( A )`` an ``m`` by ``k`` by ``batchCount`` strided_batched matrix,
|
|
``op( B )`` a ``k`` by ``n`` by ``batchCount`` strided_batched matrix, and
|
|
``C`` an ``m`` by ``n`` by ``batchCount`` strided_batched matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
specifies the form of op( A ).
|
|
@param[in]
|
|
transB [hipblasOperation_t]
|
|
specifies the form of op( B ).
|
|
@param[in]
|
|
m [int]
|
|
matrix dimension m.
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
k [int]
|
|
matrix dimension k.
|
|
@param[in]
|
|
alpha device pointer or host pointer specifying the scalar alpha.
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[in]
|
|
BP device array of device pointers storing each matrix B_i.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of each B_i.
|
|
@param[in]
|
|
beta device pointer or host pointer specifying the scalar beta.
|
|
@param[in, out]
|
|
CP device array of device pointers storing each matrix C_i.
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of each C_i.
|
|
@param[in]
|
|
batchCount
|
|
[int]
|
|
number of gemm operations in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHgemmBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* const AP[],
|
|
int lda,
|
|
const hipblasHalf* const BP[],
|
|
int ldb,
|
|
const hipblasHalf* beta,
|
|
hipblasHalf* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemmBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int lda,
|
|
const float* const BP[],
|
|
int ldb,
|
|
const float* beta,
|
|
float* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemmBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int lda,
|
|
const double* const BP[],
|
|
int ldb,
|
|
const double* beta,
|
|
double* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemmBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const BP[],
|
|
int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemmBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHgemmBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* const AP[],
|
|
int64_t lda,
|
|
const hipblasHalf* const BP[],
|
|
int64_t ldb,
|
|
const hipblasHalf* beta,
|
|
hipblasHalf* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemmBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
const float* const BP[],
|
|
int64_t ldb,
|
|
const float* beta,
|
|
float* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemmBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
const double* const BP[],
|
|
int64_t ldb,
|
|
const double* beta,
|
|
double* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemmBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const BP[],
|
|
int64_t ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemmBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int64_t ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The gemmStridedBatched functions perform one of the strided batched matrix-matrix operations:
|
|
|
|
C_i = alpha*op( A_i )*op( B_i ) + beta*C_i, for i = 1, ..., batchCount
|
|
|
|
where ``op( X )`` is one of:
|
|
|
|
op( X ) = X or
|
|
op( X ) = X**T or
|
|
op( X ) = X**H,
|
|
|
|
``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are strided batched matrices, with
|
|
``op( A )`` an ``m`` by ``k`` by ``batchCount`` strided_batched matrix,
|
|
``op( B )`` a ``k`` by ``n`` by ``batchCount`` strided_batched matrix, and
|
|
``C`` an ``m`` by ``n`` by ``batchCount`` strided_batched matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
specifies the form of op( A ).
|
|
@param[in]
|
|
transB [hipblasOperation_t]
|
|
specifies the form of op( B ).
|
|
@param[in]
|
|
m [int]
|
|
matrix dimension m.
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
k [int]
|
|
matrix dimension k.
|
|
@param[in]
|
|
alpha device pointer or host pointer specifying the scalar alpha.
|
|
@param[in]
|
|
AP device pointer pointing to the first matrix A_1.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one A_i matrix to the next A_(i + 1).
|
|
@param[in]
|
|
BP device pointer pointing to the first matrix B_1.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of each B_i.
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
stride from the start of one B_i matrix to the next B_(i + 1).
|
|
@param[in]
|
|
beta device pointer or host pointer specifying the scalar beta.
|
|
@param[in, out]
|
|
CP device pointer pointing to the first matrix C_1.
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of each C_i.
|
|
@param[in]
|
|
strideC [hipblasStride]
|
|
stride from the start of one C_i matrix to the next C_(i + 1).
|
|
@param[in]
|
|
batchCount
|
|
[int]
|
|
number of gemm operatons in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHgemmStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* AP,
|
|
int lda,
|
|
long long strideA,
|
|
const hipblasHalf* BP,
|
|
int ldb,
|
|
long long strideB,
|
|
const hipblasHalf* beta,
|
|
hipblasHalf* CP,
|
|
int ldc,
|
|
long long strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemmStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
long long strideA,
|
|
const float* BP,
|
|
int ldb,
|
|
long long strideB,
|
|
const float* beta,
|
|
float* CP,
|
|
int ldc,
|
|
long long strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemmStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
long long strideA,
|
|
const double* BP,
|
|
int ldb,
|
|
long long strideB,
|
|
const double* beta,
|
|
double* CP,
|
|
int ldc,
|
|
long long strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemmStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
long long strideA,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
long long strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc,
|
|
long long strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemmStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
long long strideA,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
long long strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc,
|
|
long long strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHgemmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* AP,
|
|
int64_t lda,
|
|
long long strideA,
|
|
const hipblasHalf* BP,
|
|
int64_t ldb,
|
|
long long strideB,
|
|
const hipblasHalf* beta,
|
|
hipblasHalf* CP,
|
|
int64_t ldc,
|
|
long long strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgemmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
long long strideA,
|
|
const float* BP,
|
|
int64_t ldb,
|
|
long long strideB,
|
|
const float* beta,
|
|
float* CP,
|
|
int64_t ldc,
|
|
long long strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgemmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
long long strideA,
|
|
const double* BP,
|
|
int64_t ldb,
|
|
long long strideB,
|
|
const double* beta,
|
|
double* CP,
|
|
int64_t ldc,
|
|
long long strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgemmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
long long strideA,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
long long strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc,
|
|
long long strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgemmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
long long strideA,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
long long strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc,
|
|
long long strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The herk functions perform one of the matrix-matrix operations for a Hermitian rank-k update:
|
|
|
|
C := alpha*op( A )*op( A )^H + beta*C
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and
|
|
``C`` is an ``n`` x ``n`` Hermitian matrix stored as either upper or lower.
|
|
|
|
op( A ) = A, and A is n by k if transA == HIPBLAS_OP_N
|
|
op( A ) = A^H and A is k by n if transA == HIPBLAS_OP_C
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : ``c`` and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_C: op(A) = A^H
|
|
- HIPBLAS_ON_N: op(A) = A
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and A does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP pointer storing matrix A on the GPU.
|
|
Matrix dimension is ( lda, k ) when transA = HIPBLAS_OP_N. Otherwise, (lda, n).
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
If transA = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP pointer storing matrix C on the GPU.
|
|
The imaginary component of the diagonal elements are not used but are set to zero, except for quick return.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherk(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherk(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherk_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherk_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The herkBatched functions perform a batch of the matrix-matrix operations for a Hermitian rank-k update:
|
|
|
|
C_i := alpha*op( A_i )*op( A_i )^H + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and
|
|
``C_i`` is an ``n`` x ``n`` Hermitian matrix stored as either upper or lower.
|
|
|
|
op( A_i ) = A_i, and A_i is n by k if transA == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^H and A_i is k by n if transA == HIPBLAS_OP_C
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_C: op(A) = A^H
|
|
- HIPBLAS_OP_N: op(A) = A
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and A does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix_i A of dimension (lda, k)
|
|
when transA is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If transA = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP device array of device pointers storing each matrix C_i on the GPU.
|
|
The imaginary components of the diagonal elements are not used but are set to zero, except for quick return.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherkBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const float* beta,
|
|
hipComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherkBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const double* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherkBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const float* beta,
|
|
hipComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherkBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const double* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The herkStridedBatched functions perform a batch of the matrix-matrix operations for a Hermitian rank-k update:
|
|
|
|
C_i := alpha*op( A_i )*op( A_i )^H + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and
|
|
``C_i`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower.
|
|
|
|
op( A_i ) = A_i, and A_i is n by k if transA == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^H and A_i is k by n if transA == HIPBLAS_OP_C
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_C: op(A) = A^H
|
|
- HIPBLAS_OP_N: op(A) = A
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and A does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP Device pointer to the first matrix A_1 on the GPU of dimension (lda, k)
|
|
when transA is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If transA = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP Device pointer to the first matrix C_1 on the GPU.
|
|
The imaginary components of the diagonal elements are not used but are set to zero, except for quick return.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
@param[inout]
|
|
strideC [hipblasStride]
|
|
stride from the start of one matrix (C_i) to the next one (C_i+1).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherkStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherkStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherkStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherkStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The herkx functions perform one of the matrix-matrix operations for a Hermitian rank-k update:
|
|
|
|
C := alpha*op( A )*op( B )^H + beta*C
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` matrices, and
|
|
``C`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower.
|
|
This routine should only be used when the caller can guarantee that the result of ``op( A )*op( B )^T`` will be Hermitian.
|
|
|
|
op( A ) = A, op( B ) = B, and A and B are n by k if trans == HIPBLAS_OP_N
|
|
op( A ) = A^H, op( B ) = B^H, and A and B are k by n if trans == HIPBLAS_OP_C
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : ``c`` and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_C: op( A ) = A^H, op( B ) = B^H
|
|
- HIPBLAS_OP_N: op( A ) = A, op( B ) = B
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP pointer storing matrix A on the GPU.
|
|
Matrix dimension is ( lda, k ) when trans = HIPBLAS_OP_N. Otherwise, (lda, n).
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
if trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
@param[in]
|
|
BP pointer storing matrix B on the GPU.
|
|
Matrix dimension is ( ldb, k ) when trans = HIPBLAS_OP_N. Otherwise, (ldb, n).
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B.
|
|
If trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP pointer storing matrix C on the GPU.
|
|
The imaginary components of the diagonal elements are not used but are set to zero, except for quick return.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherkx(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherkx(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherkx_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherkx_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The herkxBatched functions perform a batch of the matrix-matrix operations for a Hermitian rank-k update:
|
|
|
|
C_i := alpha*op( A_i )*op( B_i )^H + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` matrices, and
|
|
``C_i`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower.
|
|
This routine should only be used when the caller can guarantee that the result of ``op( A )*op( B )^T`` will be Hermitian.
|
|
|
|
op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == HIPBLAS_OP_C
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_C: op(A) = A^H
|
|
- HIPBLAS_OP_N: op(A) = A
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix_i A of dimension (lda, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
BP device array of device pointers storing each matrix_i B of dimension (ldb, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n).
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i.
|
|
If trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP device array of device pointers storing each matrix C_i on the GPU.
|
|
The imaginary components of the diagonal elements are not used but are set to zero, except for quick return.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherkxBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const BP[],
|
|
int ldb,
|
|
const float* beta,
|
|
hipComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherkxBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherkxBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const BP[],
|
|
int64_t ldb,
|
|
const float* beta,
|
|
hipComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherkxBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int64_t ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The herkxStridedBatched functions perform a batch of the matrix-matrix operations for a Hermitian rank-k update:
|
|
|
|
C_i := alpha*op( A_i )*op( B_i )^H + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` matrices, and
|
|
``C_i`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower.
|
|
This routine should only be used when the caller can guarantee that the result of ``op( A )*op( B )^T`` will be Hermitian.
|
|
|
|
op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == HIPBLAS_OP_C
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_C: op( A_i ) = A_i^H, op( B_i ) = B_i^H
|
|
- HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP Device pointer to the first matrix A_1 on the GPU of dimension (lda, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
|
|
@param[in]
|
|
BP Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n).
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i.
|
|
If trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
stride from the start of one matrix (B_i) to the next one (B_i+1).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP Device pointer to the first matrix C_1 on the GPU.
|
|
The imaginary components of the diagonal elements are not used but are set to zero, except for quick return.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
@param[inout]
|
|
strideC [hipblasStride]
|
|
stride from the start of one matrix (C_i) to the next one (C_i+1).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherkxStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherkxStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCherkxStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZherkxStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The her2k functions perform one of the matrix-matrix operations for a Hermitian rank-2k update:
|
|
|
|
C := alpha*op( A )*op( B )^H + conj(alpha)*op( B )*op( A )^H + beta*C
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` matrices, and
|
|
``C`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower.
|
|
|
|
op( A ) = A, op( B ) = B, and A and B are n by k if trans == HIPBLAS_OP_N
|
|
op( A ) = A^H, op( B ) = B^H, and A and B are k by n if trans == HIPBLAS_OP_C
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : ``c`` and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_C: op( A ) = A^H, op( B ) = B^H
|
|
- HIPBLAS_OP_N: op( A ) = A, op( B ) = B
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP pointer storing matrix A on the GPU.
|
|
Matrix dimension is ( lda, k ) when trans = HIPBLAS_OP_N. Otherwise, (lda, n).
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
If trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
@param[in]
|
|
BP pointer storing matrix B on the GPU.
|
|
Matrix dimension is ( ldb, k ) when trans = HIPBLAS_OP_N. Otherwise, (ldb, n).
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B.
|
|
If trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP pointer storing matrix C on the GPU.
|
|
The imaginary components of the diagonal elements are not used but are set to zero, except for quick return.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2k(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2k(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2k_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2k_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The her2kBatched functions perform a batch of the matrix-matrix operations for a Hermitian rank-2k update:
|
|
|
|
C_i := alpha*op( A_i )*op( B_i )^H + conj(alpha)*op( B_i )*op( A_i )^H + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` matrices, and
|
|
``C_i`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower.
|
|
|
|
op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == HIPBLAS_OP_C
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_C: op(A) = A^H
|
|
- HIPBLAS_OP_N: op(A) = A
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix_i A of dimension (lda, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
@param[in]
|
|
BP device array of device pointers storing each matrix_i B of dimension (ldb, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n).
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i.
|
|
If trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP device array of device pointers storing each matrix C_i on the GPU.
|
|
The imaginary components of the diagonal elements are not used but are set to zero, except for quick return.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2kBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const BP[],
|
|
int ldb,
|
|
const float* beta,
|
|
hipComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2kBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2kBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const BP[],
|
|
int64_t ldb,
|
|
const float* beta,
|
|
hipComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2kBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int64_t ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The her2kStridedBatched functions perform a batch of the matrix-matrix operations for a Hermitian rank-2k update:
|
|
|
|
C_i := alpha*op( A_i )*op( B_i )^H + conj(alpha)*op( B_i )*op( A_i )^H + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` matrices, and
|
|
``C_i`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower.
|
|
|
|
op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == HIPBLAS_OP_C
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_C: op( A_i ) = A_i^H, op( B_i ) = B_i^H
|
|
- HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP Device pointer to the first matrix A_1 on the GPU of dimension (lda, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
if trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
|
|
@param[in]
|
|
BP Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n).
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i.
|
|
If trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
stride from the start of one matrix (B_i) to the next one (B_i+1).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP Device pointer to the first matrix C_1 on the GPU.
|
|
The imaginary components of the diagonal elements are not used but are set to zero, except for quick return.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
@param[inout]
|
|
strideC [hipblasStride]
|
|
stride from the start of one matrix (C_i) to the next one (C_i+1).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2kStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2kStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCher2kStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZher2kStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The symm functions perform one of the matrix-matrix operations:
|
|
|
|
C := alpha*A*B + beta*C if side == HIPBLAS_SIDE_LEFT,
|
|
C := alpha*B*A + beta*C if side == HIPBLAS_SIDE_RIGHT,
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``B`` and ``C`` are ``m`` by ``n`` matrices, and
|
|
``A`` is a symmetric matrix stored as either upper or lower.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: C := alpha*A*B + beta*C
|
|
- HIPBLAS_SIDE_RIGHT: C := alpha*B*A + beta*C
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of B and C. m >= 0.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of B and C. n >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A and B are not referenced.
|
|
|
|
@param[in]
|
|
AP pointer storing matrix A on the GPU.
|
|
A is m by m if side == HIPBLAS_SIDE_LEFT.
|
|
A is n by n if side == HIPBLAS_SIDE_RIGHT.
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
Otherwise, lda >= max( 1, n ).
|
|
|
|
@param[in]
|
|
BP pointer storing matrix B on the GPU.
|
|
Matrix dimension is m by n.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B. ldb >= max( 1, m ).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP pointer storing matrix C on the GPU.
|
|
Matrix dimension is m by n.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, m ).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
const float* BP,
|
|
int ldb,
|
|
const float* beta,
|
|
float* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
const double* BP,
|
|
int ldb,
|
|
const double* beta,
|
|
double* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
const float* BP,
|
|
int64_t ldb,
|
|
const float* beta,
|
|
float* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
const double* BP,
|
|
int64_t ldb,
|
|
const double* beta,
|
|
double* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
symmBatched performs a batch of the matrix-matrix operations:
|
|
|
|
C_i := alpha*A_i*B_i + beta*C_i if side == HIPBLAS_SIDE_LEFT,
|
|
C_i := alpha*B_i*A_i + beta*C_i if side == HIPBLAS_SIDE_RIGHT,
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, and
|
|
``A_i`` is a symmetric matrix stored as either upper or lower.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: C_i := alpha*A_i*B_i + beta*C_i
|
|
- HIPBLAS_SIDE_RIGHT: C_i := alpha*B_i*A_i + beta*C_i
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of B_i and C_i. m >= 0.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of B_i and C_i. n >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A_i and B_i are not referenced.
|
|
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i on the GPU.
|
|
A_i is m by m if side == HIPBLAS_SIDE_LEFT.
|
|
A_i is n by n if side == HIPBLAS_SIDE_RIGHT.
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
Otherwise, lda >= max( 1, n ).
|
|
|
|
@param[in]
|
|
BP device array of device pointers storing each matrix B_i on the GPU.
|
|
Matrix dimension is m by n.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i. ldb >= max( 1, m ).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C_i does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP device array of device pointers storing each matrix C_i on the GPU.
|
|
Matrix dimension is m by n.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C_i. ldc >= max( 1, m ).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int lda,
|
|
const float* const BP[],
|
|
int ldb,
|
|
const float* beta,
|
|
float* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int lda,
|
|
const double* const BP[],
|
|
int ldb,
|
|
const double* beta,
|
|
double* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const BP[],
|
|
int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
const float* const BP[],
|
|
int64_t ldb,
|
|
const float* beta,
|
|
float* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
const double* const BP[],
|
|
int64_t ldb,
|
|
const double* beta,
|
|
double* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const BP[],
|
|
int64_t ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int64_t ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The symmStridedBatched functions perform a batch of the matrix-matrix operations:
|
|
|
|
C_i := alpha*A_i*B_i + beta*C_i if side == HIPBLAS_SIDE_LEFT,
|
|
C_i := alpha*B_i*A_i + beta*C_i if side == HIPBLAS_SIDE_RIGHT,
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, and
|
|
``A_i`` is a symmetric matrix stored as either upper or lower.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: C_i := alpha*A_i*B_i + beta*C_i
|
|
- HIPBLAS_SIDE_RIGHT: C_i := alpha*B_i*A_i + beta*C_i
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of B_i and C_i. m >= 0.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of B_i and C_i. n >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A_i and B_i are not referenced.
|
|
|
|
@param[in]
|
|
AP device pointer to first matrix A_1.
|
|
A_i is m by m if side == HIPBLAS_SIDE_LEFT.
|
|
A_i is n by n if side == HIPBLAS_SIDE_RIGHT.
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
Otherwise, lda >= max( 1, n ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
|
|
@param[in]
|
|
BP device pointer to first matrix B_1 of dimension (ldb, n) on the GPU.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i. ldb >= max( 1, m ).
|
|
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
stride from the start of one matrix (B_i) to the next one (B_i+1).
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP device pointer to first matrix C_1 of dimension (ldc, n) on the GPU.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, m ).
|
|
|
|
@param[inout]
|
|
strideC [hipblasStride]
|
|
stride from the start of one matrix (C_i) to the next one (C_i+1).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
float* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
double* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsymmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
float* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsymmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
double* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsymmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsymmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The syrk functions perform one of the matrix-matrix operations for a symmetric rank-k update:
|
|
|
|
C := alpha*op( A )*op( A )^T + beta*C
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and
|
|
``C`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower.
|
|
|
|
op( A ) = A, and A is n by k if transA == HIPBLAS_OP_N
|
|
op( A ) = A^T and A is k by n if transA == HIPBLAS_OP_T
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_T: op(A) = A^T
|
|
- HIPBLAS_OP_N: op(A) = A
|
|
- HIPBLAS_OP_C: op(A) = A^T
|
|
- HIPBLAS_OP_C is not supported for complex types. See cherk
|
|
and zherk.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and A does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP pointer storing matrix A on the GPU.
|
|
Matrix dimension is ( lda, k ) when transA = HIPBLAS_OP_N. Otherwise, (lda, n).
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
If transA = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP pointer storing matrix C on the GPU.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrk(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
const float* beta,
|
|
float* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrk(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
const double* beta,
|
|
double* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrk(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrk(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrk_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
const float* beta,
|
|
float* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrk_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
const double* beta,
|
|
double* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrk_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrk_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The syrkBatched functions performs a batch of the matrix-matrix operations for a symmetric rank-k update:
|
|
|
|
C_i := alpha*op( A_i )*op( A_i )^T + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` is an ``n`` by ``k`` matrix, and
|
|
``C_i`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower.
|
|
|
|
op( A_i ) = A_i, and A_i is n by k if transA == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^T and A_i is k by n if transA == HIPBLAS_OP_T
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_T: op(A) = A^T
|
|
- HIPBLAS_OP_N: op(A) = A
|
|
- HIPBLAS_OP_C: op(A) = A^T
|
|
- HIPBLAS_OP_C is not supported for complex types. See cherk
|
|
and zherk.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix_i A of dimension (lda, k)
|
|
when transA is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If transA = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP device array of device pointers storing each matrix C_i on the GPU.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrkBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int lda,
|
|
const float* beta,
|
|
float* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrkBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int lda,
|
|
const double* beta,
|
|
double* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrkBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrkBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrkBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
const float* beta,
|
|
float* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrkBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
const double* beta,
|
|
double* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrkBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrkBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The syrkStridedBatched functions perform a batch of the matrix-matrix operations for a symmetric rank-k update:
|
|
|
|
C_i := alpha*op( A_i )*op( A_i )^T + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` is an ``n`` by ``k`` matrix, and
|
|
``C_i`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower.
|
|
|
|
op( A_i ) = A_i, and A_i is n by k if transA == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^T and A_i is k by n if transA == HIPBLAS_OP_T
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_T: op(A) = A^T
|
|
- HIPBLAS_OP_N: op(A) = A
|
|
- HIPBLAS_OP_C: op(A) = A^T
|
|
- HIPBLAS_OP_C is not supported for complex types. See cherk
|
|
and zherk.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP Device pointer to the first matrix A_1 on the GPU of dimension (lda, k)
|
|
when transA is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If transA = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP Device pointer to the first matrix C_1 on the GPU.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
@param[inout]
|
|
strideC [hipblasStride]
|
|
stride from the start of one matrix (C_i) to the next one (C_i+1).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrkStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* beta,
|
|
float* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrkStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* beta,
|
|
double* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrkStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrkStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrkStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* beta,
|
|
float* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrkStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* beta,
|
|
double* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrkStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrkStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The syr2k functions perform one of the matrix-matrix operations for a symmetric rank-2k update:
|
|
|
|
C := alpha*(op( A )*op( B )^T + op( B )*op( A )^T) + beta*C
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` matrices, and
|
|
``C`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower.
|
|
|
|
op( A ) = A, op( B ) = B, and A and B are n by k if trans == HIPBLAS_OP_N
|
|
op( A ) = A^T, op( B ) = B^T, and A and B are k by n if trans == HIPBLAS_OP_T
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_T: op( A ) = A^T, op( B ) = B^T
|
|
- HIPBLAS_OP_N: op( A ) = A, op( B ) = B
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A) and op(B). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP Pointer storing matrix A on the GPU.
|
|
Matrix dimension is ( lda, k ) when trans = HIPBLAS_OP_N. Otherwise, (lda, n).
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
If trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
@param[in]
|
|
BP pointer storing matrix B on the GPU.
|
|
Matrix dimension is ( ldb, k ) when trans = HIPBLAS_OP_N. Otherwise, (ldb, n).
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B.
|
|
If trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP pointer storing matrix C on the GPU.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2k(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
const float* BP,
|
|
int ldb,
|
|
const float* beta,
|
|
float* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2k(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
const double* BP,
|
|
int ldb,
|
|
const double* beta,
|
|
double* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2k(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2k(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2k_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
const float* BP,
|
|
int64_t ldb,
|
|
const float* beta,
|
|
float* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2k_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
const double* BP,
|
|
int64_t ldb,
|
|
const double* beta,
|
|
double* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2k_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2k_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The syr2kBatched functions perform a batch of the matrix-matrix operations for a symmetric rank-2k update:
|
|
|
|
C_i := alpha*(op( A_i )*op( B_i )^T + op( B_i )*op( A_i )^T) + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` matrices, and
|
|
``C_i`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower.
|
|
|
|
op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == HIPBLAS_OP_T
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_T: op( A_i ) = A_i^T, op( B_i ) = B_i^T
|
|
- HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix_i A of dimension (lda, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
@param[in]
|
|
BP device array of device pointers storing each matrix_i B of dimension (ldb, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n).
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B.
|
|
If trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP device array of device pointers storing each matrix C_i on the GPU.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2kBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int lda,
|
|
const float* const BP[],
|
|
int ldb,
|
|
const float* beta,
|
|
float* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2kBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int lda,
|
|
const double* const BP[],
|
|
int ldb,
|
|
const double* beta,
|
|
double* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2kBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const BP[],
|
|
int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2kBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2kBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
const float* const BP[],
|
|
int64_t ldb,
|
|
const float* beta,
|
|
float* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2kBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
const double* const BP[],
|
|
int64_t ldb,
|
|
const double* beta,
|
|
double* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2kBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const BP[],
|
|
int64_t ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2kBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int64_t ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The syr2kStridedBatched functions perform a batch of the matrix-matrix operations for a symmetric rank-2k update:
|
|
|
|
C_i := alpha*(op( A_i )*op( B_i )^T + op( B_i )*op( A_i )^T) + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` matrices, and
|
|
``C_i`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower.
|
|
|
|
op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == HIPBLAS_OP_T
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_T: op( A_i ) = A_i^T, op( B_i ) = B_i^T
|
|
- HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP Device pointer to the first matrix A_1 on the GPU of dimension (lda, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
|
|
@param[in]
|
|
BP Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n).
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i.
|
|
If trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
stride from the start of one matrix (B_i) to the next one (B_i+1).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP Device pointer to the first matrix C_1 on the GPU.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
@param[inout]
|
|
strideC [hipblasStride]
|
|
stride from the start of one matrix (C_i) to the next one (C_i+1).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2kStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
float* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2kStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
double* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2kStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2kStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyr2kStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
float* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyr2kStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
double* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyr2kStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyr2kStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The syrkx functions performs one of the matrix-matrix operations for a symmetric rank-k update:
|
|
|
|
C := alpha*op( A )*op( B )^T + beta*C
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` matrices, and
|
|
``C`` is a symmetric ``n`` by ``n ``matrix stored as either upper or lower.
|
|
This routine should only be used when the caller can guarantee that the result of ``op( A )*op( B )^T`` will be symmetric.
|
|
|
|
op( A ) = A, op( B ) = B, and A and B are n by k if trans == HIPBLAS_OP_N
|
|
op( A ) = A^T, op( B ) = B^T, and A and B are k by n if trans == HIPBLAS_OP_T
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_T: op( A ) = A^T, op( B ) = B^T
|
|
- HIPBLAS_OP_N: op( A ) = A, op( B ) = B
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A) and op(B). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP pointer storing matrix A on the GPU.
|
|
Matrix dimension is ( lda, k ) when trans = HIPBLAS_OP_N. Otherwise, (lda, n).
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
If trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
BP pointer storing matrix B on the GPU.
|
|
Matrix dimension is ( ldb, k ) when trans = HIPBLAS_OP_N. Otherwise, (ldb, n).
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B.
|
|
if trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP pointer storing matrix C on the GPU.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrkx(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
const float* BP,
|
|
int ldb,
|
|
const float* beta,
|
|
float* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrkx(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
const double* BP,
|
|
int ldb,
|
|
const double* beta,
|
|
double* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrkx(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrkx(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrkx_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
const float* BP,
|
|
int64_t ldb,
|
|
const float* beta,
|
|
float* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrkx_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
const double* BP,
|
|
int64_t ldb,
|
|
const double* beta,
|
|
double* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrkx_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrkx_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The syrkxBatched functions perform a batch of the matrix-matrix operations for a symmetric rank-k update:
|
|
|
|
C_i := alpha*op( A_i )*op( B_i )^T + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are an ``n`` by ``k`` matrix, and
|
|
``C_i`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower.
|
|
This routine should only be used when the caller can guarantee that the result of ``op( A_i )*op( B_i )^T`` will be symmetric.
|
|
|
|
op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == HIPBLAS_OP_T
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_T: op( A_i ) = A_i^T, op( B_i ) = B_i^T
|
|
- HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and A does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix_i A of dimension (lda, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
BP device array of device pointers storing each matrix_i B of dimension (ldb, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n).
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B.
|
|
If trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP device array of device pointers storing each matrix C_i on the GPU.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrkxBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int lda,
|
|
const float* const BP[],
|
|
int ldb,
|
|
const float* beta,
|
|
float* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrkxBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int lda,
|
|
const double* const BP[],
|
|
int ldb,
|
|
const double* beta,
|
|
double* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrkxBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const BP[],
|
|
int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrkxBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrkxBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
const float* const BP[],
|
|
int64_t ldb,
|
|
const float* beta,
|
|
float* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrkxBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
const double* const BP[],
|
|
int64_t ldb,
|
|
const double* beta,
|
|
double* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrkxBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const BP[],
|
|
int64_t ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrkxBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int64_t ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The syrkxStridedBatched functions perform a batch of the matrix-matrix operations for a symmetric rank-k update:
|
|
|
|
C_i := alpha*op( A_i )*op( B_i )^T + beta*C_i
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` matrices, and
|
|
``C_i`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower.
|
|
This routine should only be used when the caller can guarantee that the result of ``op( A_i )*op( B_i )^T`` will be symmetric.
|
|
|
|
op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N
|
|
op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == HIPBLAS_OP_T
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix
|
|
- HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_T: op( A_i ) = A_i^T, op( B_i ) = B_i^T
|
|
- HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows and columns of C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of op(A). k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP Device pointer to the first matrix A_1 on the GPU of dimension (lda, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n).
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If trans = HIPBLAS_OP_N, lda >= max( 1, n ).
|
|
Otherwise, lda >= max( 1, k ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
|
|
@param[in]
|
|
BP Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k)
|
|
when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n).
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i.
|
|
If trans = HIPBLAS_OP_N, ldb >= max( 1, n ).
|
|
Otherwise, ldb >= max( 1, k ).
|
|
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
stride from the start of one matrix (B_i) to the next one (B_i+1).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP Device pointer to the first matrix C_1 on the GPU.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, n ).
|
|
|
|
@param[inout]
|
|
strideC [hipblasStride]
|
|
stride from the start of one matrix (C_i) to the next one (C_i+1).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrkxStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
float* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrkxStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
double* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrkxStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrkxStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSsyrkxStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
float* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDsyrkxStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
double* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCsyrkxStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZsyrkxStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The geam functions perform one of the matrix-matrix operations:
|
|
|
|
C = alpha*op( A ) + beta*op( B ),
|
|
|
|
where op( X ) is one of
|
|
|
|
op( X ) = X or
|
|
op( X ) = X**T or
|
|
op( X ) = X**H,
|
|
|
|
``alpha`` and ``beta`` are scalars, and ``A``, ``B`` and ``C`` are matrices, with
|
|
``op( A )`` an ``m`` by ``n`` matrix, ``op( B )`` an ``m`` by`` n`` matrix, and ``C`` an ``m`` by ``n`` matrix.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
specifies the form of op( A ).
|
|
@param[in]
|
|
transB [hipblasOperation_t]
|
|
specifies the form of op( B ).
|
|
@param[in]
|
|
m [int]
|
|
matrix dimension m.
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
alpha device pointer or host pointer specifying the scalar alpha.
|
|
@param[in]
|
|
AP device pointer storing matrix A.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
@param[in]
|
|
beta device pointer or host pointer specifying the scalar beta.
|
|
@param[in]
|
|
BP device pointer storing matrix B.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of B.
|
|
@param[in, out]
|
|
CP device pointer storing matrix C.
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of C.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgeam(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
const float* beta,
|
|
const float* BP,
|
|
int ldb,
|
|
float* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgeam(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
const double* beta,
|
|
const double* BP,
|
|
int ldb,
|
|
double* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeam(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* beta,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
hipComplex* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeam(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* beta,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
hipDoubleComplex* CP,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgeam_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
const float* beta,
|
|
const float* BP,
|
|
int64_t ldb,
|
|
float* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgeam_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
const double* beta,
|
|
const double* BP,
|
|
int64_t ldb,
|
|
double* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeam_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* beta,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
hipComplex* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeam_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* beta,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The geamBatched functions perform one of the batched matrix-matrix operations:
|
|
|
|
C_i = alpha*op( A_i ) + beta*op( B_i ) for i = 0, 1, ... batchCount - 1
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)``, ``op(B_i)``, and ``C_i`` are ``m`` by ``n`` matrices,
|
|
and ``op( X )`` is one of:
|
|
|
|
op( X ) = X or
|
|
op( X ) = X**T
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
specifies the form of op( A ).
|
|
@param[in]
|
|
transB [hipblasOperation_t]
|
|
specifies the form of op( B ).
|
|
@param[in]
|
|
m [int]
|
|
matrix dimension m.
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
alpha device pointer or host pointer specifying the scalar alpha.
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i on the GPU.
|
|
Each A_i is of dimension ( lda, k ), where k is m
|
|
when transA == HIPBLAS_OP_N and
|
|
is n when transA == HIPBLAS_OP_T.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
@param[in]
|
|
beta device pointer or host pointer specifying the scalar beta.
|
|
@param[in]
|
|
BP device array of device pointers storing each matrix B_i on the GPU.
|
|
Each B_i is of dimension ( ldb, k ), where k is m
|
|
when transB == HIPBLAS_OP_N and
|
|
is n when transB == HIPBLAS_OP_T.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of B.
|
|
@param[in, out]
|
|
CP device array of device pointers storing each matrix C_i on the GPU.
|
|
Each C_i is of dimension ( ldc, n ).
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of C.
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances i in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgeamBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int lda,
|
|
const float* beta,
|
|
const float* const BP[],
|
|
int ldb,
|
|
float* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgeamBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int lda,
|
|
const double* beta,
|
|
const double* const BP[],
|
|
int ldb,
|
|
double* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeamBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* beta,
|
|
const hipComplex* const BP[],
|
|
int ldb,
|
|
hipComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeamBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* beta,
|
|
const hipDoubleComplex* const BP[],
|
|
int ldb,
|
|
hipDoubleComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgeamBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
const float* beta,
|
|
const float* const BP[],
|
|
int64_t ldb,
|
|
float* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgeamBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
const double* beta,
|
|
const double* const BP[],
|
|
int64_t ldb,
|
|
double* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeamBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* beta,
|
|
const hipComplex* const BP[],
|
|
int64_t ldb,
|
|
hipComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeamBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* beta,
|
|
const hipDoubleComplex* const BP[],
|
|
int64_t ldb,
|
|
hipDoubleComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The geamStridedBatched functions perform one of the batched matrix-matrix operations:
|
|
|
|
C_i = alpha*op( A_i ) + beta*op( B_i ) for i = 0, 1, ... batchCount - 1
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A_i)``, ``op(B_i)``, and ``C_i`` are ``m`` by ``n`` matrices,
|
|
and ``op( X )`` is one of:
|
|
|
|
op( X ) = X or
|
|
op( X ) = X**T
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
specifies the form of op( A ).
|
|
|
|
@param[in]
|
|
transB [hipblasOperation_t]
|
|
specifies the form of op( B ).
|
|
|
|
@param[in]
|
|
m [int]
|
|
matrix dimension m.
|
|
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
|
|
@param[in]
|
|
alpha device pointer or host pointer specifying the scalar alpha.
|
|
|
|
@param[in]
|
|
AP device pointer to the first matrix A_0 on the GPU.
|
|
Each A_i is of dimension ( lda, k ), where k is m
|
|
when transA == HIPBLAS_OP_N and
|
|
is n when transA == HIPBLAS_OP_T.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
|
|
@param[in]
|
|
beta device pointer or host pointer specifying the scalar beta.
|
|
|
|
@param[in]
|
|
BP pointer to the first matrix B_0 on the GPU.
|
|
Each B_i is of dimension ( ldb, k ), where k is m
|
|
when transB == HIPBLAS_OP_N and
|
|
is n when transB == HIPBLAS_OP_T.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of B.
|
|
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
stride from the start of one matrix (B_i) to the next one (B_i+1).
|
|
|
|
@param[in, out]
|
|
CP pointer to the first matrix C_0 on the GPU.
|
|
Each C_i is of dimension ( ldc, n ).
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of C.
|
|
|
|
@param[in]
|
|
strideC [hipblasStride]
|
|
stride from the start of one matrix (C_i) to the next one (C_i+1).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances i in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgeamStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* beta,
|
|
const float* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
float* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgeamStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* beta,
|
|
const double* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
double* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeamStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* beta,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
hipComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeamStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* beta,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
hipDoubleComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgeamStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* beta,
|
|
const float* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
float* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgeamStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* beta,
|
|
const double* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
double* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeamStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* beta,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
hipComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeamStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* beta,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The hemm functions perform one of the matrix-matrix operations:
|
|
|
|
C := alpha*A*B + beta*C if side == HIPBLAS_SIDE_LEFT,
|
|
C := alpha*B*A + beta*C if side == HIPBLAS_SIDE_RIGHT,
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``B`` and ``C`` are ``m`` by ``n`` matrices, and
|
|
``A`` is a Hermitian matrix stored as either upper or lower.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : ``c`` and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: C := alpha*A*B + beta*C
|
|
- HIPBLAS_SIDE_RIGHT: C := alpha*B*A + beta*C
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of B and C. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
n specifies the number of columns of B and C. k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A and B are not referenced.
|
|
|
|
@param[in]
|
|
AP pointer storing matrix A on the GPU.
|
|
- A is m by m if side == HIPBLAS_SIDE_LEFT.
|
|
- A is n by n if side == HIPBLAS_SIDE_RIGHT.
|
|
- Only the upper/lower triangular part is accessed.
|
|
- The imaginary component of the diagonal elements is not used.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
Otherwise, lda >= max( 1, n ).
|
|
|
|
@param[in]
|
|
BP pointer storing matrix B on the GPU.
|
|
Matrix dimension is m by n.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B. ldb >= max( 1, m ).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP pointer storing matrix C on the GPU.
|
|
Matrix dimension is m by n.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, m ).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The hemmBatched functions perform a batch of the matrix-matrix operations:
|
|
|
|
C_i := alpha*A_i*B_i + beta*C_i if side == HIPBLAS_SIDE_LEFT,
|
|
C_i := alpha*B_i*A_i + beta*C_i if side == HIPBLAS_SIDE_RIGHT,
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, and
|
|
``A_i`` is a Hermitian matrix stored as either upper or lower.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: C_i := alpha*A_i*B_i + beta*C_i
|
|
- HIPBLAS_SIDE_RIGHT: C_i := alpha*B_i*A_i + beta*C_i
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of B_i and C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of B_i and C_i. k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A_i and B_i are not referenced.
|
|
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i on the GPU.
|
|
- A_i is m by m if side == HIPBLAS_SIDE_LEFT.
|
|
- A_i is n by n if side == HIPBLAS_SIDE_RIGHT.
|
|
- Only the upper/lower triangular part is accessed.
|
|
- The imaginary component of the diagonal elements is not used.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
Otherwise, lda >= max( 1, n ).
|
|
|
|
@param[in]
|
|
BP device array of device pointers storing each matrix B_i on the GPU.
|
|
Matrix dimension is m by n.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i. ldb >= max( 1, m ).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C_i need not be set before entry.
|
|
|
|
@param[in]
|
|
CP device array of device pointers storing each matrix C_i on the GPU.
|
|
Matrix dimension is m by n.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C_i. ldc >= max( 1, m ).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const BP[],
|
|
int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const BP[],
|
|
int64_t ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const BP[],
|
|
int64_t ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The hemmStridedBatched functions perform a batch of the matrix-matrix operations:
|
|
|
|
C_i := alpha*A_i*B_i + beta*C_i if side == HIPBLAS_SIDE_LEFT,
|
|
C_i := alpha*B_i*A_i + beta*C_i if side == HIPBLAS_SIDE_RIGHT,
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, and
|
|
``A_i`` is a Hermitian matrix stored as either upper or lower.
|
|
|
|
- Supported precisions in rocBLAS : ``c`` and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: C_i := alpha*A_i*B_i + beta*C_i
|
|
- HIPBLAS_SIDE_RIGHT: C_i := alpha*B_i*A_i + beta*C_i
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of rows of B_i and C_i. n >= 0.
|
|
|
|
@param[in]
|
|
k [int]
|
|
k specifies the number of columns of B_i and C_i. k >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A_i and B_i are not referenced.
|
|
|
|
@param[in]
|
|
AP device pointer to first matrix A_1
|
|
- A_i is m by m if side == HIPBLAS_SIDE_LEFT.
|
|
- A_i is n by n if side == HIPBLAS_SIDE_RIGHT.
|
|
- Only the upper/lower triangular part is accessed.
|
|
- The imaginary component of the diagonal elements is not used.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A_i.
|
|
If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
Otherwise, lda >= max( 1, n ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
|
|
@param[in]
|
|
BP device pointer to first matrix B_1 of dimension (ldb, n) on the GPU.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i.
|
|
If side = HIPBLAS_OP_N, ldb >= max( 1, m ).
|
|
Otherwise, ldb >= max( 1, n ).
|
|
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
stride from the start of one matrix (B_i) to the next one (B_i+1).
|
|
|
|
@param[in]
|
|
beta
|
|
beta specifies the scalar beta. When beta is
|
|
zero, then C does not need to be set before entry.
|
|
|
|
@param[in]
|
|
CP device pointer to first matrix C_1 of dimension (ldc, n) on the GPU.
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, m ).
|
|
|
|
@param[inout]
|
|
strideC [hipblasStride]
|
|
stride from the start of one matrix (C_i) to the next one (C_i+1).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int n,
|
|
int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasChemmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZhemmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
int64_t n,
|
|
int64_t k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
|
|
\details
|
|
|
|
The trmm functions perform one of the matrix-matrix operations:
|
|
|
|
C := alpha*op( A )*B, or C := alpha*B*op( A )
|
|
|
|
where ``alpha`` is a scalar, ``B`` and ``C`` are ``m`` by ``n`` matrices, ``A`` is a unit,
|
|
non-unit, upper, or lower triangular matrix, and ``op( A )`` is one of:
|
|
|
|
op( A ) = A or op( A ) = A^T or op( A ) = A^H.
|
|
|
|
Note that trmm can provide in-place functionality by passing in the same address for both
|
|
matrices ``B`` and ``C`` and setting ``ldb`` equal to ``ldc``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
Specifies whether op(A) multiplies B from the left or right as follows:
|
|
- HIPBLAS_SIDE_LEFT: C := alpha*op( A )*B.
|
|
- HIPBLAS_SIDE_RIGHT: C := alpha*B*op( A ).
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
Specifies whether the matrix A is an upper or lower triangular matrix as follows:
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
Specifies the form of op(A) to be used in the matrix multiplication as follows:
|
|
- HIPBLAS_OP_N: op(A) = A.
|
|
- HIPBLAS_OP_T: op(A) = A^T.
|
|
- HIPBLAS_OP_C: op(A) = A^H.
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
Specifies whether or not A is unit triangular as follows:
|
|
- HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of B and C. m >= 0.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of B and C. n >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A is not referenced and B does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
A Device pointer to matrix A on the GPU.
|
|
A has dimension ( lda, k ), where k is m
|
|
when side == HIPBLAS_SIDE_LEFT and
|
|
is n when side == HIPBLAS_SIDE_RIGHT.
|
|
- When uplo == HIPBLAS_FILL_MODE_UPPER, the leading k by k
|
|
upper triangular part of the array A must contain the upper
|
|
triangular matrix and the strictly lower triangular part of
|
|
A is not referenced.
|
|
- When uplo == HIPBLAS_FILL_MODE_LOWER, the leading k by k
|
|
lower triangular part of the array A must contain the lower
|
|
triangular matrix and the strictly upper triangular part of
|
|
A is not referenced.
|
|
Note that when diag == HIPBLAS_DIAG_UNIT, the diagonal elements of
|
|
A are not referenced either, but are assumed to be unity.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
- If side == HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
- If side == HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ).
|
|
|
|
@param[inout]
|
|
B Device pointer to the matrix B of dimension (ldb, n) on the GPU.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B. ldb >= max( 1, m ).
|
|
|
|
@param[in]
|
|
C Device pointer to the matrix C of dimension (ldc, n) on the GPU.
|
|
Users can pass in the same matrix B to parameter C to achieve
|
|
in-place functionality for trmm.
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C. ldc >= max( 1, m ).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
int lda,
|
|
const float* B,
|
|
int ldb,
|
|
float* C,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
int lda,
|
|
const double* B,
|
|
int ldb,
|
|
double* C,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
int lda,
|
|
const hipComplex* B,
|
|
int ldb,
|
|
hipComplex* C,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
int lda,
|
|
const hipDoubleComplex* B,
|
|
int ldb,
|
|
hipDoubleComplex* C,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* A,
|
|
int64_t lda,
|
|
const float* B,
|
|
int64_t ldb,
|
|
float* C,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* A,
|
|
int64_t lda,
|
|
const double* B,
|
|
int64_t ldb,
|
|
double* C,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
int64_t lda,
|
|
const hipComplex* B,
|
|
int64_t ldb,
|
|
hipComplex* C,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
int64_t lda,
|
|
const hipDoubleComplex* B,
|
|
int64_t ldb,
|
|
hipDoubleComplex* C,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The trmmBatched functions perform one of the batched matrix-matrix operations:
|
|
|
|
C_i := alpha*op( A_i )*B_i, or C_i := alpha*B_i*op( A_i ) for i = 0, 1, ... batchCount -1
|
|
|
|
where ``alpha`` is a scalar, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, ``A_i`` is a unit,
|
|
non-unit, upper, or lower triangular matrix, and ``op( A_i )`` is one of:
|
|
|
|
op( A_i ) = A_i or op( A_i ) = A_i^T or op( A_i ) = A_i^H.
|
|
|
|
Note that trmmBatched can provide in-place functionality by passing in the same address for both
|
|
matrices ``B`` and ``C`` and by setting ``ldb`` equal to ``ldc``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
Specifies whether op(A_i) multiplies B_i from the left or right as follows:
|
|
- HIPBLAS_SIDE_LEFT: B_i := alpha*op( A_i )*B_i.
|
|
- HIPBLAS_SIDE_RIGHT: B_i := alpha*B_i*op( A_i ).
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
Specifies whether the matrix A is an upper or lower triangular matrix as follows:
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
Specifies the form of op(A_i) to be used in the matrix multiplication as follows:
|
|
- HIPBLAS_OP_N: op(A_i) = A_i.
|
|
- HIPBLAS_OP_T: op(A_i) = A_i^T.
|
|
- HIPBLAS_OP_C: op(A_i) = A_i^H.
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
Specifies whether or not A_i is unit triangular as follows:
|
|
- HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of B_i and C_i. m >= 0.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of B_i and C_i. n >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A_i is not referenced and B_i does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
A Device array of device pointers storing each matrix A_i on the GPU.
|
|
Each A_i is of dimension ( lda, k ), where k is m
|
|
when side == HIPBLAS_SIDE_LEFT and
|
|
is n when side == HIPBLAS_SIDE_RIGHT.
|
|
- When uplo == HIPBLAS_FILL_MODE_UPPER, the leading k by k
|
|
upper triangular part of the array A must contain the upper
|
|
triangular matrix and the strictly lower triangular part of
|
|
A is not referenced.
|
|
- When uplo == HIPBLAS_FILL_MODE_LOWER, the leading k by k
|
|
lower triangular part of the array A must contain the lower
|
|
triangular matrix and the strictly upper triangular part of
|
|
A is not referenced.
|
|
- Note that when diag == HIPBLAS_DIAG_UNIT, the diagonal elements of
|
|
A_i are not referenced either, but are assumed to be unity.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
- If side == HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
- If side == HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ).
|
|
|
|
@param[inout]
|
|
B device array of device pointers storing each matrix B_i of
|
|
dimension (ldb, n) on the GPU.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i. ldb >= max( 1, m ).
|
|
|
|
@param[in]
|
|
C device array of device pointers storing each matrix C_i of
|
|
dimension (ldc, n) on the GPU. Users can pass in the same
|
|
matrices B to parameter C to achieve in-place functionality of trmmBatched.
|
|
|
|
@param[in]
|
|
ldc ldc specifies the first dimension of C_i. ldc >= max( 1, m ).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances i in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
int lda,
|
|
const float* const B[],
|
|
int ldb,
|
|
float* const C[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
int lda,
|
|
const double* const B[],
|
|
int ldb,
|
|
double* const C[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
int lda,
|
|
const hipComplex* const B[],
|
|
int ldb,
|
|
hipComplex* const C[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
int lda,
|
|
const hipDoubleComplex* const B[],
|
|
int ldb,
|
|
hipDoubleComplex* const C[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
int64_t lda,
|
|
const float* const B[],
|
|
int64_t ldb,
|
|
float* const C[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
int64_t lda,
|
|
const double* const B[],
|
|
int64_t ldb,
|
|
double* const C[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
int64_t lda,
|
|
const hipComplex* const B[],
|
|
int64_t ldb,
|
|
hipComplex* const C[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const B[],
|
|
int64_t ldb,
|
|
hipDoubleComplex* const C[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The trmmStridedBatched functions perform one of the strided_batched matrix-matrix operations:
|
|
|
|
C_i := alpha*op( A_i )*B_i, or C_i := alpha*B_i*op( A_i ) for i = 0, 1, ... batchCount -1
|
|
|
|
where ``alpha`` is a scalar, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, ``A_i`` is a unit, or
|
|
non-unit, upper, or lower triangular matrix, and ``op( A_i )`` is one of:
|
|
|
|
op( A_i ) = A_i or op( A_i ) = A_i^T or op( A_i ) = A_i^H.
|
|
|
|
Note that trmmStridedBatched can provide in-place functionality by passing
|
|
in the same address for both matrices ``B`` and ``C`` and by setting ``ldb`` equal to ``ldc``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
Specifies whether op(A_i) multiplies B_i from the left or right as follows:
|
|
- HIPBLAS_SIDE_LEFT: C_i := alpha*op( A_i )*B_i.
|
|
- HIPBLAS_SIDE_RIGHT: C_i := alpha*B_i*op( A_i ).
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
Specifies whether the matrix A is an upper or lower triangular matrix as follows:
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
Specifies the form of op(A_i) to be used in the matrix multiplication as follows:
|
|
- HIPBLAS_OP_N: op(A_i) = A_i.
|
|
- HIPBLAS_OP_T: op(A_i) = A_i^T.
|
|
- HIPBLAS_OP_C: op(A_i) = A_i^H.
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
Specifies whether or not A_i is unit triangular as follows:
|
|
- HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of B_i and C_i. m >= 0.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of B_i and C_i. n >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
alpha specifies the scalar alpha. When alpha is
|
|
zero, then A_i is not referenced and B_i does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
A Device pointer to the first matrix A_0 on the GPU.
|
|
Each A_i is of dimension ( lda, k ), where k is m
|
|
when side == HIPBLAS_SIDE_LEFT and
|
|
is n when side == HIPBLAS_SIDE_RIGHT.
|
|
- When uplo == HIPBLAS_FILL_MODE_UPPER, the leading k by k
|
|
upper triangular part of the array A must contain the upper
|
|
triangular matrix and the strictly lower triangular part of
|
|
A is not referenced.
|
|
- When uplo == HIPBLAS_FILL_MODE_LOWER, the leading k by k
|
|
lower triangular part of the array A must contain the lower
|
|
triangular matrix and the strictly upper triangular part of
|
|
A is not referenced.
|
|
- Note that when diag == HIPBLAS_DIAG_UNIT, the diagonal elements of
|
|
A_i are not referenced either, but are assumed to be unity.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
- if side == HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
- if side == HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
|
|
@param[inout]
|
|
B Device pointer to the first matrix B_0 on the GPU. Each B_i is of
|
|
dimension ( ldb, n ).
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B_i. ldb >= max( 1, m ).
|
|
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
stride from the start of one matrix (B_i) to the next one (B_i+1).
|
|
|
|
@param[in]
|
|
C Device pointer to the first matrix C_0 on the GPU. Each C_i is of
|
|
dimension ( ldc, n ).
|
|
|
|
@param[in]
|
|
ldc [int]
|
|
ldc specifies the first dimension of C_i. ldc >= max( 1, m ).
|
|
|
|
@param[in]
|
|
strideC [hipblasStride]
|
|
stride from the start of one matrix (C_i) to the next one (C_i+1).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances i in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* B,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
float* C,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* B,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
double* C,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* B,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
hipComplex* C,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* B,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
hipDoubleComplex* C,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrmmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* A,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* B,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
float* C,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrmmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* A,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* B,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
double* C,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrmmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* B,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
hipComplex* C,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrmmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* B,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
hipDoubleComplex* C,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
|
|
The trsm functions solve:
|
|
|
|
op(A)*X = alpha*B or X*op(A) = alpha*B,
|
|
|
|
where ``alpha`` is a scalar, ``X`` and ``B`` are ``m`` by ``n`` matrices,
|
|
``A`` is triangular matrix, and ``op(A)`` is one of:
|
|
|
|
op( A ) = A or op( A ) = A^T or op( A ) = A^H.
|
|
|
|
The matrix ``X`` is overwritten on ``B``.
|
|
|
|
Note about memory allocation:
|
|
When trsm is launched with a ``k`` evenly divisible by the internal block size of 128
|
|
and is no larger than 10 of these blocks, the API uses preallocated
|
|
memory found in the handle to increase overall performance (where ``k`` is ``m`` when
|
|
``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``). For more information on
|
|
preallocated memory in the handle, see the Device Memory Allocation
|
|
in rocBLAS section of the rocBLAS API Reference.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B.
|
|
- HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: op(A) = A.
|
|
- HIPBLAS_OP_T: op(A) = A^T.
|
|
- HIPBLAS_OP_C: op(A) = A^H.
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of B. m >= 0.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of B. n >= 0.
|
|
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer specifying the scalar alpha. When alpha is
|
|
&zero, then A is not referenced and B does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
AP device pointer storing matrix A.
|
|
Of dimension ( lda, k ), where k is m
|
|
when HIPBLAS_SIDE_LEFT and
|
|
is n when HIPBLAS_SIDE_RIGHT.
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
- If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
- If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ).
|
|
|
|
@param[in,out]
|
|
BP device pointer storing matrix B.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B. ldb >= max( 1, m ).
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
float* BP,
|
|
int ldb);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
double* BP,
|
|
int ldb);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipComplex* BP,
|
|
int ldb);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipDoubleComplex* BP,
|
|
int ldb);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
float* BP,
|
|
int64_t ldb);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
double* BP,
|
|
int64_t ldb);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipComplex* BP,
|
|
int64_t ldb);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipDoubleComplex* BP,
|
|
int64_t ldb);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The trsmBatched functions perform the following batched operation:
|
|
|
|
op(A_i)*X_i = alpha*B_i or X_i*op(A_i) = alpha*B_i, for i = 1, ..., batchCount.
|
|
|
|
where ``alpha`` is a scalar, ``X`` and ``B`` are batched ``m`` by ``n`` matrices,
|
|
``A`` is a triangular batched matrix, and ``op(A)`` is one of:
|
|
|
|
op( A ) = A or op( A ) = A^T or op( A ) = A^H.
|
|
|
|
Each matrix ``X_i`` is overwritten on ``B_i`` for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
Note about memory allocation:
|
|
When trsm is launched with a ``k`` evenly divisible by the internal block size of 128
|
|
and is no larger than 10 of these blocks, the API uses preallocated
|
|
memory found in the handle to increase overall performance (where ``k`` is ``m`` when
|
|
``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``). For more information on
|
|
preallocated memory in the handle, see the Device Memory Allocation
|
|
in rocBLAS section of the rocBLAS API Reference.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B.
|
|
- HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: op(A) = A.
|
|
- HIPBLAS_OP_T: op(A) = A^T.
|
|
- HIPBLAS_OP_C: op(A) = A^H.
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular.
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of each B_i. m >= 0.
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of each B_i. n >= 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer specifying the scalar alpha. When alpha is
|
|
&zero, then A is not referenced and B does not need to be set before
|
|
entry.
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i on the GPU.
|
|
Matricies are of dimension ( lda, k ), where k is m
|
|
when HIPBLAS_SIDE_LEFT and is n when HIPBLAS_SIDE_RIGHT.
|
|
Only the upper/lower triangular part is accessed.
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of each A_i.
|
|
- If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
- If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ).
|
|
@param[in,out]
|
|
BP device array of device pointers storing each matrix B_i on the GPU.
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of each B_i. ldb >= max( 1, m ).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of trsm operatons in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int lda,
|
|
float* const BP[],
|
|
int ldb,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int lda,
|
|
double* const BP[],
|
|
int ldb,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
hipComplex* const BP[],
|
|
int ldb,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
hipDoubleComplex* const BP[],
|
|
int ldb,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
float* const BP[],
|
|
int64_t ldb,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
double* const BP[],
|
|
int64_t ldb,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
hipComplex* const BP[],
|
|
int64_t ldb,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
hipDoubleComplex* const BP[],
|
|
int64_t ldb,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The trsmStridedBatched functions perform the following strided batched operation:
|
|
|
|
op(A_i)*X_i = alpha*B_i or X_i*op(A_i) = alpha*B_i, for i = 1, ..., batchCount.
|
|
|
|
where ``alpha`` is a scalar, ``X`` and ``B`` are strided batched ``m`` by ``n`` matrices,
|
|
``A`` is a triangular strided batched matrix, and ``op(A)`` is one of:
|
|
|
|
op( A ) = A or op( A ) = A^T or op( A ) = A^H.
|
|
|
|
Each matrix ``X_i`` is overwritten on ``B_i`` for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
Note about memory allocation:
|
|
When trsm is launched with a ``k`` evenly divisible by the internal block size of 128
|
|
and is no larger than 10 of these blocks, the API uses preallocated
|
|
memory found in the handle to increase overall performance (where ``k`` is ``m`` when
|
|
``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``). For more information on
|
|
preallocated memory in the handle, see the Device Memory Allocation
|
|
in rocBLAS section of the rocBLAS API Reference.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B.
|
|
- HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: op(A) = A.
|
|
- HIPBLAS_OP_T: op(A) = A^T.
|
|
- HIPBLAS_OP_C: op(A) = A^H.
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular.
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of each B_i. m >= 0.
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of each B_i. n >= 0.
|
|
@param[in]
|
|
alpha
|
|
device pointer or host pointer specifying the scalar alpha. When alpha is
|
|
&zero, then A is not referenced and B does not need to be set before
|
|
entry.
|
|
@param[in]
|
|
AP device pointer pointing to the first matrix A_1.
|
|
Of dimension ( lda, k ), where k is m
|
|
when HIPBLAS_SIDE_LEFT and
|
|
is n when HIPBLAS_SIDE_RIGHT.
|
|
Only the upper/lower triangular part is accessed.
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of each A_i.
|
|
- If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
- If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ).
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one A_i matrix to the next A_(i + 1).
|
|
@param[in,out]
|
|
BP device pointer pointing to the first matrix B_1.
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of each B_i. ldb >= max( 1, m ).
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
stride from the start of one B_i matrix to the next B_(i + 1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of trsm operatons in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
float* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
double* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* BP,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrsmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
float* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrsmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
double* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrsmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
hipComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrsmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* BP,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The trtri functions compute the inverse of a matrix A, namely:
|
|
|
|
invA
|
|
|
|
and write the result into ``invA``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
- If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced.
|
|
- If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced.
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- 'HIPBLAS_DIAG_NON_UNIT', A is non-unit triangular.
|
|
- 'HIPBLAS_DIAG_UNIT', A is unit triangular.
|
|
@param[in]
|
|
n [int]
|
|
size of matrix A and invA.
|
|
@param[in]
|
|
AP device pointer storing matrix A.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
@param[out]
|
|
invA device pointer storing matrix invA.
|
|
@param[in]
|
|
ldinvA [int]
|
|
specifies the leading dimension of invA.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrtri(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* AP,
|
|
int lda,
|
|
float* invA,
|
|
int ldinvA);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrtri(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* AP,
|
|
int lda,
|
|
double* invA,
|
|
int ldinvA);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrtri(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipComplex* invA,
|
|
int ldinvA);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrtri(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipDoubleComplex* invA,
|
|
int ldinvA);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The trtriBatched functions compute the inverse of ``A_i`` and write into ``invA_i``, where
|
|
``A_i`` and ``invA_i`` are the ``i``-th matrices in the batch,
|
|
for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- 'HIPBLAS_DIAG_NON_UNIT', A is non-unit triangular.
|
|
- 'HIPBLAS_DIAG_UNIT', A is unit triangular.
|
|
@param[in]
|
|
n [int]
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[out]
|
|
invA device array of device pointers storing the inverse of each matrix A_i.
|
|
Partial inplace operation is supported, see below.
|
|
- If UPLO = 'U', the leading N-by-N upper triangular part of the invA will store
|
|
the inverse of the upper triangular matrix, and the strictly lower
|
|
triangular part of invA is cleared.
|
|
- If UPLO = 'L', the leading N-by-N lower triangular part of the invA will store
|
|
the inverse of the lower triangular matrix, and the strictly upper
|
|
triangular part of invA is cleared.
|
|
@param[in]
|
|
ldinvA [int]
|
|
specifies the leading dimension of each invA_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
numbers of matrices in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrtriBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* const AP[],
|
|
int lda,
|
|
float* invA[],
|
|
int ldinvA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrtriBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* const AP[],
|
|
int lda,
|
|
double* invA[],
|
|
int ldinvA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrtriBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
hipComplex* invA[],
|
|
int ldinvA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrtriBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
hipDoubleComplex* invA[],
|
|
int ldinvA,
|
|
int batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The trtriStridedBatched functions compute the inverse of ``A_i`` and write into ``invA_i``, where
|
|
``A_i`` and ``invA_i`` are the ``i``-th matrices in the batch,
|
|
for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower (HIPBLAS_FILL_MODE_LOWER):
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- 'HIPBLAS_DIAG_NON_UNIT', A is non-unit triangular.
|
|
- 'HIPBLAS_DIAG_UNIT', A is unit triangular.
|
|
@param[in]
|
|
n [int]
|
|
@param[in]
|
|
AP device pointer pointing to address of first matrix A_1.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
"batch stride a": stride from the start of one A_i matrix to the next A_(i + 1).
|
|
@param[out]
|
|
invA device pointer storing the inverses of each matrix A_i.
|
|
Partial inplace operation is supported, see below.
|
|
- If UPLO = 'U', the leading N-by-N upper triangular part of the invA will store
|
|
the inverse of the upper triangular matrix, and the strictly lower
|
|
triangular part of invA is cleared.
|
|
- If UPLO = 'L', the leading N-by-N lower triangular part of the invA will store
|
|
the inverse of the lower triangular matrix, and the strictly upper
|
|
triangular part of invA is cleared.
|
|
@param[in]
|
|
ldinvA [int]
|
|
specifies the leading dimension of each invA_i.
|
|
@param[in]
|
|
stride_invA [hipblasStride]
|
|
"batch stride invA": stride from the start of one invA_i matrix to the next invA_(i + 1).
|
|
@param[in]
|
|
batchCount [int]
|
|
numbers of matrices in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasStrtriStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
float* invA,
|
|
int ldinvA,
|
|
hipblasStride stride_invA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDtrtriStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
double* invA,
|
|
int ldinvA,
|
|
hipblasStride stride_invA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCtrtriStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipComplex* invA,
|
|
int ldinvA,
|
|
hipblasStride stride_invA,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZtrtriStridedBatched(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasDiagType_t diag,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* invA,
|
|
int ldinvA,
|
|
hipblasStride stride_invA,
|
|
int batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The dgmm functions perform one of the matrix-matrix operations:
|
|
|
|
C = A * diag(x) if side == HIPBLAS_SIDE_RIGHT
|
|
C = diag(x) * A if side == HIPBLAS_SIDE_LEFT
|
|
|
|
where ``C`` and ``A`` are ``m`` by ``n`` dimensional matrices, ``diag( x )`` is a diagonal matrix,
|
|
and ``x`` is a vector of dimension ``n`` if ``side == HIPBLAS_SIDE_RIGHT`` and dimension ``m``
|
|
if ``side == HIPBLAS_SIDE_LEFT``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
specifies the side of diag(x).
|
|
@param[in]
|
|
m [int]
|
|
matrix dimension m.
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
AP device pointer storing matrix A.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between values of x
|
|
@param[in, out]
|
|
CP device pointer storing matrix C.
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of C.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdgmm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const float* AP,
|
|
int lda,
|
|
const float* x,
|
|
int incx,
|
|
float* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdgmm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const double* AP,
|
|
int lda,
|
|
const double* x,
|
|
int incx,
|
|
double* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdgmm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipComplex* CP,
|
|
int ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdgmm(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipDoubleComplex* CP,
|
|
int ldc);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdgmm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* AP,
|
|
int64_t lda,
|
|
const float* x,
|
|
int64_t incx,
|
|
float* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdgmm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* AP,
|
|
int64_t lda,
|
|
const double* x,
|
|
int64_t incx,
|
|
double* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdgmm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipComplex* CP,
|
|
int64_t ldc);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdgmm_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The dgmmBatched functions perform one of the batched matrix-matrix operations:
|
|
|
|
C_i = A_i * diag(x_i) for i = 0, 1, ... batchCount-1 if side == HIPBLAS_SIDE_RIGHT
|
|
C_i = diag(x_i) * A_i for i = 0, 1, ... batchCount-1 if side == HIPBLAS_SIDE_LEFT
|
|
|
|
where ``C_i`` and ``A_i`` are ``m`` by ``n`` dimensional matrices, ``diag(x_i)`` is a diagonal matrix
|
|
and ``x_i`` is vector of dimension ``n`` if ``side == HIPBLAS_SIDE_RIGHT`` and dimension ``m``
|
|
if ``side == HIPBLAS_SIDE_LEFT``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
specifies the side of diag(x).
|
|
@param[in]
|
|
m [int]
|
|
matrix dimension m.
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
AP device array of device pointers storing each matrix A_i on the GPU.
|
|
Each A_i is of dimension ( lda, n ).
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i on the GPU.
|
|
Each x_i is of dimension n if side == HIPBLAS_SIDE_RIGHT and dimension
|
|
m if side == HIPBLAS_SIDE_LEFT.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between values of x_i.
|
|
@param[in, out]
|
|
CP device array of device pointers storing each matrix C_i on the GPU.
|
|
Each C_i is of dimension ( ldc, n ).
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of C_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdgmmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const float* const AP[],
|
|
int lda,
|
|
const float* const x[],
|
|
int incx,
|
|
float* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdgmmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const double* const AP[],
|
|
int lda,
|
|
const double* const x[],
|
|
int incx,
|
|
double* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdgmmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const hipComplex* const AP[],
|
|
int lda,
|
|
const hipComplex* const x[],
|
|
int incx,
|
|
hipComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdgmmBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* const AP[],
|
|
int lda,
|
|
const hipDoubleComplex* const x[],
|
|
int incx,
|
|
hipDoubleComplex* const CP[],
|
|
int ldc,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdgmmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* const AP[],
|
|
int64_t lda,
|
|
const float* const x[],
|
|
int64_t incx,
|
|
float* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdgmmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* const AP[],
|
|
int64_t lda,
|
|
const double* const x[],
|
|
int64_t incx,
|
|
double* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdgmmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* const AP[],
|
|
int64_t lda,
|
|
const hipComplex* const x[],
|
|
int64_t incx,
|
|
hipComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdgmmBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* const AP[],
|
|
int64_t lda,
|
|
const hipDoubleComplex* const x[],
|
|
int64_t incx,
|
|
hipDoubleComplex* const CP[],
|
|
int64_t ldc,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS Level 3 API </b>
|
|
|
|
\details
|
|
The dgmmStridedBatched functions perform one of the batched matrix-matrix operations:
|
|
|
|
C_i = A_i * diag(x_i) if side == HIPBLAS_SIDE_RIGHT for i = 0, 1, ... batchCount-1
|
|
C_i = diag(x_i) * A_i if side == HIPBLAS_SIDE_LEFT for i = 0, 1, ... batchCount-1
|
|
|
|
where ``C_i`` and ``A_i`` are ``m`` by ``n`` dimensional matrices, ``diag(x_i)`` is a diagonal matrix,
|
|
and ``x_i`` is a vector of dimension ``n`` if ``side == HIPBLAS_SIDE_RIGHT`` and dimension ``m``
|
|
if ``side == HIPBLAS_SIDE_LEFT``.
|
|
|
|
- Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
specifies the side of diag(x).
|
|
@param[in]
|
|
m [int]
|
|
matrix dimension m.
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
AP device pointer to the first matrix A_0 on the GPU.
|
|
Each A_i is of dimension ( lda, n ).
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
stride from the start of one matrix (A_i) to the next one (A_i+1).
|
|
@param[in]
|
|
x pointer to the first vector x_0 on the GPU.
|
|
Each x_i is of dimension n if side == HIPBLAS_SIDE_RIGHT and dimension
|
|
m if side == HIPBLAS_SIDE_LEFT.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between values of x.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector(x_i) to the next one (x_i+1).
|
|
@param[in, out]
|
|
CP device pointer to the first matrix C_0 on the GPU.
|
|
Each C_i is of dimension ( ldc, n ).
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of C.
|
|
@param[in]
|
|
strideC [hipblasStride]
|
|
stride from the start of one matrix (C_i) to the next one (C_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances i in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdgmmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const float* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
float* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdgmmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const double* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
double* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdgmmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const hipComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdgmmStridedBatched(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int m,
|
|
int n,
|
|
const hipDoubleComplex* AP,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* CP,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSdgmmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const float* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
float* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDdgmmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const double* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
double* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCdgmmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZdgmmStridedBatched_64(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
int64_t m,
|
|
int64_t n,
|
|
const hipDoubleComplex* AP,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* CP,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount);
|
|
//! @}
|
|
|
|
/*
|
|
* ===========================================================================
|
|
* SOLVER APIs
|
|
* ===========================================================================
|
|
*/
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The getrf functions compute the LU factorization of a general ``n``-by-``n`` matrix ``A``
|
|
using partial pivoting with row interchanges. The LU factorization can
|
|
be done without pivoting if ``ipiv`` is passed as a nullptr.
|
|
|
|
When ``ipiv`` is not null, the factorization has the form:
|
|
|
|
\f[
|
|
A = PLU
|
|
\f]
|
|
|
|
where ``P`` is a permutation matrix, ``L`` is lower triangular with unit
|
|
diagonal elements, and ``U`` is upper triangular.
|
|
|
|
When ``ipiv`` is null, the factorization is done without pivoting:
|
|
|
|
\f[
|
|
A = LU
|
|
\f]
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The number of columns and rows of the matrix A.
|
|
@param[inout]
|
|
A pointer to type. Array on the GPU of dimension lda*n.
|
|
- On entry, the n-by-n matrix A to be factored.
|
|
- On exit, the factors L and U from the factorization.
|
|
- The unit diagonal elements of L are not stored.
|
|
@param[in]
|
|
lda int. lda >= n.
|
|
Specifies the leading dimension of A.
|
|
@param[out]
|
|
ipiv pointer to int. Array on the GPU of dimension n.
|
|
The vector of pivot indices. Elements of ipiv are 1-based indices.
|
|
For 1 <= i <= n, row i of the
|
|
matrix was interchanged with row ipiv[i].
|
|
Matrix P of the factorization can be derived from ipiv.
|
|
This factorization can be done without pivoting if ipiv is passed
|
|
in as a nullptr.
|
|
@param[out]
|
|
info pointer to a int on the GPU.
|
|
- If info = 0, successful exit.
|
|
- If info = j > 0, U is singular. U[j,j] is the first zero pivot.
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgetrf(
|
|
hipblasHandle_t handle, const int n, float* A, const int lda, int* ipiv, int* info);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgetrf(
|
|
hipblasHandle_t handle, const int n, double* A, const int lda, int* ipiv, int* info);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgetrf(
|
|
hipblasHandle_t handle, const int n, hipComplex* A, const int lda, int* ipiv, int* info);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgetrf(
|
|
hipblasHandle_t handle, const int n, hipDoubleComplex* A, const int lda, int* ipiv, int* info);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The getrfBatched functions compute the LU factorization of a batch of general
|
|
``n``-by-``n`` matrices using partial pivoting with row interchanges. The LU factorization can
|
|
be done without pivoting if ``ipiv`` is passed as a nullptr.
|
|
|
|
When ipiv is not null, the factorization of matrix \f$A_i\f$ in the batch has the form:
|
|
|
|
\f[
|
|
A_i = P_iL_iU_i
|
|
\f]
|
|
|
|
where \f$P_i\f$ is a permutation matrix, \f$L_i\f$ is lower triangular with unit
|
|
diagonal elements, and \f$U_i\f$ is upper triangular.
|
|
|
|
When ``ipiv`` is null, the factorization is done without pivoting:
|
|
|
|
\f[
|
|
A_i = L_iU_i
|
|
\f]
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The number of columns and rows of all matrices A_i in the batch.
|
|
@param[inout]
|
|
A array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
|
|
- On entry, the n-by-n matrices A_i to be factored.
|
|
- On exit, the factors L_i and U_i from the factorizations.
|
|
- The unit diagonal elements of L_i are not stored.
|
|
@param[in]
|
|
lda int. lda >= n.
|
|
Specifies the leading dimension of matrices A_i.
|
|
@param[out]
|
|
ipiv pointer to int. Array on the GPU.
|
|
Contains the vectors of pivot indices ipiv_i (corresponding to A_i).
|
|
Dimension of ipiv_i is n.
|
|
Elements of ipiv_i are 1-based indices.
|
|
For each instance A_i in the batch and for 1 <= j <= n, row j of the
|
|
matrix A_i was interchanged with row ipiv_i[j].
|
|
Matrix P_i of the factorization can be derived from ipiv_i.
|
|
This factorization can be done without pivoting if ipiv is passed
|
|
in as a nullptr.
|
|
@param[out]
|
|
info pointer to int. Array of batchCount integers on the GPU.
|
|
- If info[i] = 0, successful exit for factorization of A_i.
|
|
- If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero pivot.
|
|
@param[in]
|
|
batchCount int. batchCount >= 0.
|
|
Number of matrices in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgetrfBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
float* const A[],
|
|
const int lda,
|
|
int* ipiv,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgetrfBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
double* const A[],
|
|
const int lda,
|
|
int* ipiv,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgetrfBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
hipComplex* const A[],
|
|
const int lda,
|
|
int* ipiv,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgetrfBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
hipDoubleComplex* const A[],
|
|
const int lda,
|
|
int* ipiv,
|
|
int* info,
|
|
const int batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The getrfStridedBatched functions compute the LU factorization of a batch of
|
|
general ``n``-by-``n`` matrices using partial pivoting with row interchanges. The LU factorization can
|
|
be done without pivoting if ``ipiv`` is passed as a nullptr.
|
|
|
|
When ``ipiv`` is not null, the factorization of matrix \f$A_i\f$ in the batch has the form:
|
|
|
|
\f[
|
|
A_i = P_iL_iU_i
|
|
\f]
|
|
|
|
where \f$P_i\f$ is a permutation matrix, \f$L_i\f$ is lower triangular with unit
|
|
diagonal elements, and \f$U_i\f$ is upper triangular.
|
|
|
|
When ``ipiv`` is null, the factorization is done without pivoting:
|
|
|
|
\f[
|
|
A_i = L_iU_i
|
|
\f]
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The number of columns and rows of all matrices A_i in the batch.
|
|
@param[inout]
|
|
A pointer to type. Array on the GPU (the size depends on the value of strideA).
|
|
- On entry, the n-by-n matrices A_i to be factored.
|
|
- On exit, the factors L_i and U_i from the factorization.
|
|
- The unit diagonal elements of L_i are not stored.
|
|
@param[in]
|
|
lda int. lda >= n.
|
|
Specifies the leading dimension of matrices A_i.
|
|
@param[in]
|
|
strideA hipblasStride.
|
|
Stride from the start of one matrix A_i to the next one A_(i+1).
|
|
There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
|
|
@param[out]
|
|
ipiv pointer to int. Array on the GPU (the size depends on the value of strideP).
|
|
Contains the vectors of pivots indices ipiv_i (corresponding to A_i).
|
|
Dimension of ipiv_i is n.
|
|
Elements of ipiv_i are 1-based indices.
|
|
For each instance A_i in the batch and for 1 <= j <= n, row j of the
|
|
matrix A_i was interchanged with row ipiv_i[j].
|
|
Matrix P_i of the factorization can be derived from ipiv_i.
|
|
The factorization here can be done without pivoting if ipiv is passed
|
|
in as a nullptr.
|
|
@param[in]
|
|
strideP hipblasStride.
|
|
Stride from the start of one vector ipiv_i to the next one ipiv_(i+1).
|
|
There is no restriction for the value of strideP. Normal use case is strideP >= n.
|
|
@param[out]
|
|
info pointer to int. Array of batchCount integers on the GPU.
|
|
- If info[i] = 0, successful exit for factorization of A_i.
|
|
- If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero pivot.
|
|
@param[in]
|
|
batchCount int. batchCount >= 0.
|
|
Number of matrices in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgetrfStridedBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
float* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
int* ipiv,
|
|
const hipblasStride strideP,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgetrfStridedBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
double* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
int* ipiv,
|
|
const hipblasStride strideP,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgetrfStridedBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
hipComplex* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
int* ipiv,
|
|
const hipblasStride strideP,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgetrfStridedBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
hipDoubleComplex* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
int* ipiv,
|
|
const hipblasStride strideP,
|
|
int* info,
|
|
const int batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The getrs functions solve a system of ``n`` linear equations on ``n`` variables in its factorized form.
|
|
|
|
They solve one of the following systems, depending on the value of ``trans``:
|
|
|
|
\f[
|
|
\begin{array}{cl}
|
|
A X = B & \: \text{not transposed,}\\
|
|
A^T X = B & \: \text{transposed, or}\\
|
|
A^H X = B & \: \text{conjugate transposed.}
|
|
\end{array}
|
|
\f]
|
|
|
|
Matrix A is defined by its triangular factors as returned by \ref hipblasSgetrf "getrf".
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
trans hipblasOperation_t.
|
|
Specifies the form of the system of equations.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The order of the system, that is, the number of columns and rows of A.
|
|
@param[in]
|
|
nrhs int. nrhs >= 0.
|
|
The number of right hand sides, that is, the number of columns
|
|
of the matrix B.
|
|
@param[in]
|
|
A pointer to type. Array on the GPU of dimension lda*n.
|
|
The factors L and U of the factorization A = P*L*U returned by \ref hipblasSgetrf "getrf".
|
|
@param[in]
|
|
lda int. lda >= n.
|
|
The leading dimension of A.
|
|
@param[in]
|
|
ipiv pointer to int. Array on the GPU of dimension n.
|
|
The pivot indices returned by \ref hipblasSgetrf "getrf".
|
|
@param[in,out]
|
|
B pointer to type. Array on the GPU of dimension ldb*nrhs.
|
|
- On entry, the right hand side matrix B.
|
|
- On exit, the solution matrix X.
|
|
@param[in]
|
|
ldb int. ldb >= n.
|
|
The leading dimension of B.
|
|
@param[out]
|
|
info pointer to a int on the host.
|
|
- If info = 0, successful exit.
|
|
- If info = j < 0, the argument at position -j is invalid.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgetrs(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
float* A,
|
|
const int lda,
|
|
const int* ipiv,
|
|
float* B,
|
|
const int ldb,
|
|
int* info);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgetrs(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
double* A,
|
|
const int lda,
|
|
const int* ipiv,
|
|
double* B,
|
|
const int ldb,
|
|
int* info);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgetrs(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
hipComplex* A,
|
|
const int lda,
|
|
const int* ipiv,
|
|
hipComplex* B,
|
|
const int ldb,
|
|
int* info);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgetrs(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
hipDoubleComplex* A,
|
|
const int lda,
|
|
const int* ipiv,
|
|
hipDoubleComplex* B,
|
|
const int ldb,
|
|
int* info);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details The getrsBatched functions solve a batch of systems of ``n`` linear equations on ``n``
|
|
variables in its factorized forms.
|
|
|
|
For each instance ``i`` in the batch, they solve one of the following systems, depending on the value of ``trans``:
|
|
|
|
\f[
|
|
\begin{array}{cl}
|
|
A_i X_i = B_i & \: \text{not transposed,}\\
|
|
A_i^T X_i = B_i & \: \text{transposed, or}\\
|
|
A_i^H X_i = B_i & \: \text{conjugate transposed.}
|
|
\end{array}
|
|
\f]
|
|
|
|
Matrix \f$A_i\f$ is defined by its triangular factors as returned by \ref hipblasSgetrfBatched "getrfBatched".
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
trans hipblasOperation_t.
|
|
Specifies the form of the system of equations of each instance in the batch.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The order of the system, that is, the number of columns and rows of all A_i matrices.
|
|
@param[in]
|
|
nrhs int. nrhs >= 0.
|
|
The number of right hand sides, that is, the number of columns
|
|
of all the matrices B_i.
|
|
@param[in]
|
|
A Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
|
|
The factors L_i and U_i of the factorization A_i = P_i*L_i*U_i returned by \ref hipblasSgetrfBatched "getrfBatched".
|
|
@param[in]
|
|
lda int. lda >= n.
|
|
The leading dimension of matrices A_i.
|
|
@param[in]
|
|
ipiv pointer to int. Array on the GPU.
|
|
Contains the vectors ipiv_i of pivot indices returned by \ref hipblasSgetrfBatched "getrfBatched".
|
|
@param[in,out]
|
|
B Array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.
|
|
- On entry, the right hand side matrices B_i.
|
|
- On exit, the solution matrix X_i of each system in the batch.
|
|
@param[in]
|
|
ldb int. ldb >= n.
|
|
The leading dimension of matrices B_i.
|
|
@param[out]
|
|
info pointer to a int on the host.
|
|
- If info = 0, successful exit.
|
|
- If info = j < 0, the argument at position -j is invalid.
|
|
@param[in]
|
|
batchCount int. batchCount >= 0.
|
|
Number of instances (systems) in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgetrsBatched(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
float* const A[],
|
|
const int lda,
|
|
const int* ipiv,
|
|
float* const B[],
|
|
const int ldb,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgetrsBatched(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
double* const A[],
|
|
const int lda,
|
|
const int* ipiv,
|
|
double* const B[],
|
|
const int ldb,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgetrsBatched(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
hipComplex* const A[],
|
|
const int lda,
|
|
const int* ipiv,
|
|
hipComplex* const B[],
|
|
const int ldb,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgetrsBatched(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
hipDoubleComplex* const A[],
|
|
const int lda,
|
|
const int* ipiv,
|
|
hipDoubleComplex* const B[],
|
|
const int ldb,
|
|
int* info,
|
|
const int batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The getrsStridedBatched functions solve a batch of systems of ``n`` linear equations
|
|
on ``n`` variables in its factorized forms.
|
|
|
|
For each instance ``i`` in the batch, they solve one of the following systems, depending on the value of ``trans``:
|
|
|
|
\f[
|
|
\begin{array}{cl}
|
|
A_i X_i = B_i & \: \text{not transposed,}\\
|
|
A_i^T X_i = B_i & \: \text{transposed, or}\\
|
|
A_i^H X_i = B_i & \: \text{conjugate transposed.}
|
|
\end{array}
|
|
\f]
|
|
|
|
Matrix \f$A_i\f$ is defined by its triangular factors as returned by \ref hipblasSgetrfStridedBatched "getrfStridedBatched".
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
trans hipblasOperation_t.
|
|
Specifies the form of the system of equations of each instance in the batch.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The order of the system, that is, the number of columns and rows of all A_i matrices.
|
|
@param[in]
|
|
nrhs int. nrhs >= 0.
|
|
The number of right hand sides, that is, the number of columns
|
|
of all the matrices B_i.
|
|
@param[in]
|
|
A pointer to type. Array on the GPU (the size depends on the value of strideA).
|
|
The factors L_i and U_i of the factorization A_i = P_i*L_i*U_i returned by \ref hipblasSgetrfStridedBatched "getrfStridedBatched".
|
|
@param[in]
|
|
lda int. lda >= n.
|
|
The leading dimension of matrices A_i.
|
|
@param[in]
|
|
strideA hipblasStride.
|
|
Stride from the start of one matrix A_i to the next one A_(i+1).
|
|
There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
|
|
@param[in]
|
|
ipiv pointer to int. Array on the GPU (the size depends on the value of strideP).
|
|
Contains the vectors ipiv_i of pivot indices returned by \ref hipblasSgetrfStridedBatched "getrfStridedBatched".
|
|
@param[in]
|
|
strideP hipblasStride.
|
|
Stride from the start of one vector ipiv_i to the next one ipiv_(i+1).
|
|
There is no restriction for the value of strideP. Normal use case is strideP >= n.
|
|
@param[in,out]
|
|
B pointer to type. Array on the GPU (size depends on the value of strideB).
|
|
- On entry, the right hand side matrices B_i.
|
|
- On exit, the solution matrix X_i of each system in the batch.
|
|
@param[in]
|
|
ldb int. ldb >= n.
|
|
The leading dimension of matrices B_i.
|
|
@param[in]
|
|
strideB hipblasStride.
|
|
Stride from the start of one matrix B_i to the next one B_(i+1).
|
|
There is no restriction for the value of strideB. Normal use case is strideB >= ldb*nrhs.
|
|
@param[out]
|
|
info pointer to a int on the host.
|
|
- If info = 0, successful exit.
|
|
- If info = j < 0, the argument at position -j is invalid.
|
|
@param[in]
|
|
batchCount int. batchCount >= 0.
|
|
Number of instances (systems) in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgetrsStridedBatched(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
float* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
const int* ipiv,
|
|
const hipblasStride strideP,
|
|
float* B,
|
|
const int ldb,
|
|
const hipblasStride strideB,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgetrsStridedBatched(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
double* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
const int* ipiv,
|
|
const hipblasStride strideP,
|
|
double* B,
|
|
const int ldb,
|
|
const hipblasStride strideB,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgetrsStridedBatched(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
hipComplex* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
const int* ipiv,
|
|
const hipblasStride strideP,
|
|
hipComplex* B,
|
|
const int ldb,
|
|
const hipblasStride strideB,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgetrsStridedBatched(hipblasHandle_t handle,
|
|
const hipblasOperation_t trans,
|
|
const int n,
|
|
const int nrhs,
|
|
hipDoubleComplex* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
const int* ipiv,
|
|
const hipblasStride strideP,
|
|
hipDoubleComplex* B,
|
|
const int ldb,
|
|
const hipblasStride strideB,
|
|
int* info,
|
|
const int batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The getriBatched functions computes the inverse \f$C_i = A_i^{-1}\f$ of a batch of general n-by-n matrices \f$A_i\f$.
|
|
|
|
The inverse is computed by solving the linear system
|
|
|
|
\f[
|
|
A_i C_i = I
|
|
\f]
|
|
|
|
where I is the identity matrix and \f$A_i\f$ is factorized as \f$A_i = P_i L_i U_i\f$, as given by \ref hipblasSgetrfBatched "getrfBatched".
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The number of rows and columns of all matrices A_i in the batch.
|
|
@param[in]
|
|
A array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
|
|
The factors L_i and U_i of the factorization A_i = P_i*L_i*U_i returned by \ref hipblasSgetrfBatched "getrfBatched".
|
|
@param[in]
|
|
lda int. lda >= n.
|
|
Specifies the leading dimension of matrices A_i.
|
|
@param[in]
|
|
ipiv pointer to int. Array on the GPU (the size depends on the value of strideP).
|
|
The pivot indices returned by \ref hipblasSgetrfBatched "getrfBatched".
|
|
ipiv can be passed in as a nullptr. This will assume that getrfBatched was called without partial pivoting.
|
|
@param[out]
|
|
C array of pointers to type. Each pointer points to an array on the GPU of dimension ldc*n.
|
|
If info[i] = 0, the inverse of matrices A_i. Otherwise, undefined.
|
|
@param[in]
|
|
ldc int. ldc >= n.
|
|
Specifies the leading dimension of C_i.
|
|
@param[out]
|
|
info pointer to int. Array of batchCount integers on the GPU.
|
|
- If info[i] = 0, successful exit for inversion of A_i.
|
|
- If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero pivot.
|
|
@param[in]
|
|
batchCount int. batchCount >= 0.
|
|
Number of matrices in the batch.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgetriBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
float* const A[],
|
|
const int lda,
|
|
int* ipiv,
|
|
float* const C[],
|
|
const int ldc,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgetriBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
double* const A[],
|
|
const int lda,
|
|
int* ipiv,
|
|
double* const C[],
|
|
const int ldc,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgetriBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
hipComplex* const A[],
|
|
const int lda,
|
|
int* ipiv,
|
|
hipComplex* const C[],
|
|
const int ldc,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgetriBatched(hipblasHandle_t handle,
|
|
const int n,
|
|
hipDoubleComplex* const A[],
|
|
const int lda,
|
|
int* ipiv,
|
|
hipDoubleComplex* const C[],
|
|
const int ldc,
|
|
int* info,
|
|
const int batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The gels functions solve an overdetermined (or underdetermined) linear system defined by an ``m``-by-``n``
|
|
matrix ``A`` and a corresponding matrix ``B``, using the QR factorization computed by \ref hipblasSgeqrf "GEQRF" (or the LQ
|
|
factorization computed by ``GELQF``).
|
|
|
|
Depending on the value of ``trans``, the problem solved by this function is either of the form:
|
|
|
|
\f[
|
|
\begin{array}{cl}
|
|
A X = B & \: \text{not transposed, or}\\
|
|
A' X = B & \: \text{transposed if real, or conjugate transposed if complex}
|
|
\end{array}
|
|
\f]
|
|
|
|
If ``m >= n`` (or ``m < n`` in the case of transpose/conjugate transpose), the system is overdetermined
|
|
and a least-squares solution approximating ``X`` is found by minimizing:
|
|
|
|
\f[
|
|
|| B - A X || \quad \text{(or} \: || B - A' X ||\text{)}
|
|
\f]
|
|
|
|
If ``m < n`` (or ``m >= n`` in the case of transpose/conjugate transpose), the system is underdetermined
|
|
and a unique solution for ``X`` is chosen such that \f$|| X ||\f$ is minimal.
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
trans hipblasOperation_t.
|
|
Specifies the form of the system of equations.
|
|
@param[in]
|
|
m int. m >= 0.
|
|
The number of rows of matrix A.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The number of columns of matrix A.
|
|
@param[in]
|
|
nrhs int. nrhs >= 0.
|
|
The number of columns of matrices B and X,
|
|
that is, the columns on the right hand side.
|
|
@param[inout]
|
|
A pointer to type. Array on the GPU of dimension lda*n.
|
|
- On entry, the matrix A.
|
|
- On exit, the QR (or LQ) factorization of A as returned by "GEQRF" (or "GELQF").
|
|
@param[in]
|
|
lda int. lda >= m.
|
|
Specifies the leading dimension of matrix A.
|
|
@param[inout]
|
|
B pointer to type. Array on the GPU of dimension ldb*nrhs.
|
|
- On entry, the matrix B.
|
|
- On exit, when info = 0, B is overwritten by the solution vectors (and the residuals in
|
|
the overdetermined cases) stored as columns.
|
|
@param[in]
|
|
ldb int. ldb >= max(m,n).
|
|
Specifies the leading dimension of matrix B.
|
|
@param[out]
|
|
info pointer to an int on the host.
|
|
- If info = 0, successful exit.
|
|
- If info = j < 0, the argument at position -j is invalid.
|
|
@param[out]
|
|
deviceInfo pointer to int on the GPU.
|
|
- If info = 0, successful exit.
|
|
- If info = i > 0, the solution could not be computed because input matrix A is
|
|
rank deficient; the i-th diagonal element of its triangular factor is zero.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgels(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
float* A,
|
|
const int lda,
|
|
float* B,
|
|
const int ldb,
|
|
int* info,
|
|
int* deviceInfo);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgels(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
double* A,
|
|
const int lda,
|
|
double* B,
|
|
const int ldb,
|
|
int* info,
|
|
int* deviceInfo);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgels(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
hipComplex* A,
|
|
const int lda,
|
|
hipComplex* B,
|
|
const int ldb,
|
|
int* info,
|
|
int* deviceInfo);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgels(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
hipDoubleComplex* A,
|
|
const int lda,
|
|
hipDoubleComplex* B,
|
|
const int ldb,
|
|
int* info,
|
|
int* deviceInfo);
|
|
///@}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The gelsBatched functions solve a batch of overdetermined (or underdetermined) linear systems
|
|
defined by a set of ``m``-by-``n`` matrices \f$A_j\f$ and corresponding matrices \f$B_j\f$, using the
|
|
QR factorizations computed by ``GEQRF_BATCHED`` (or the LQ factorizations computed by ``GELQF_BATCHED``).
|
|
|
|
For each instance in the batch, depending on the value of ``trans``, the problem solved by this function is either of the form:
|
|
|
|
\f[
|
|
\begin{array}{cl}
|
|
A_j X_j = B_j & \: \text{not transposed, or}\\
|
|
A_j' X_j = B_j & \: \text{transposed if real, or conjugate transposed if complex}
|
|
\end{array}
|
|
\f]
|
|
|
|
If ``m >= n`` (or ``m < n`` in the case of transpose/conjugate transpose), the system is overdetermined
|
|
and a least-squares solution approximating ``X_j`` is found by minimizing:
|
|
|
|
\f[
|
|
|| B_j - A_j X_j || \quad \text{(or} \: || B_j - A_j' X_j ||\text{)}
|
|
\f]
|
|
|
|
If ``m < n`` (or ``m >= n`` in the case of transpose/conjugate transpose), the system is underdetermined
|
|
and a unique solution for X_j is chosen such that \f$|| X_j ||\f$ is minimal.
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
Note that the cuBLAS backend supports only the non-transpose operation and only solves over-determined systems (``m >= n``).
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
trans hipblasOperation_t.
|
|
Specifies the form of the system of equations.
|
|
@param[in]
|
|
m int. m >= 0.
|
|
The number of rows of all matrices A_j in the batch.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The number of columns of all matrices A_j in the batch.
|
|
@param[in]
|
|
nrhs int. nrhs >= 0.
|
|
The number of columns of all matrices B_j and X_j in the batch,
|
|
that is, the columns on the right hand side.
|
|
@param[inout]
|
|
A array of pointer to type. Each pointer points to an array on the GPU of dimension lda*n.
|
|
- On entry, the matrices A_j.
|
|
- On exit, the QR (or LQ) factorizations of A_j as returned by "GEQRF_BATCHED"
|
|
(or "GELQF_BATCHED").
|
|
@param[in]
|
|
lda int. lda >= m.
|
|
Specifies the leading dimension of matrices A_j.
|
|
@param[inout]
|
|
B array of pointer to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.
|
|
- On entry, the matrices B_j.
|
|
- On exit, when info[j] = 0, B_j is overwritten by the solution vectors (and the residuals in
|
|
the overdetermined cases) stored as columns.
|
|
@param[in]
|
|
ldb int. ldb >= max(m,n).
|
|
Specifies the leading dimension of matrices B_j.
|
|
@param[out]
|
|
info pointer to an int on the host.
|
|
If info = 0, successful exit.
|
|
If info = j < 0, the argument at position -j is invalid.
|
|
@param[out]
|
|
deviceInfo pointer to int. Array of batchCount integers on the GPU.
|
|
- If deviceInfo[j] = 0, successful exit for solution of A_j.
|
|
- If deviceInfo[j] = i > 0, the solution of A_j could not be computed because input
|
|
matrix A_j is rank deficient; the i-th diagonal element of its triangular factor is zero.
|
|
@param[in]
|
|
batchCount int. batchCount >= 0.
|
|
Number of matrices in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgelsBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
float* const A[],
|
|
const int lda,
|
|
float* const B[],
|
|
const int ldb,
|
|
int* info,
|
|
int* deviceInfo,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgelsBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
double* const A[],
|
|
const int lda,
|
|
double* const B[],
|
|
const int ldb,
|
|
int* info,
|
|
int* deviceInfo,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgelsBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
hipComplex* const A[],
|
|
const int lda,
|
|
hipComplex* const B[],
|
|
const int ldb,
|
|
int* info,
|
|
int* deviceInfo,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgelsBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
hipDoubleComplex* const A[],
|
|
const int lda,
|
|
hipDoubleComplex* const B[],
|
|
const int ldb,
|
|
int* info,
|
|
int* deviceInfo,
|
|
const int batchCount);
|
|
///@}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The gelsStridedBatched functions solve a batch of overdetermined (or underdetermined) linear
|
|
systems defined by a set of ``m``-by-``n`` matrices \f$A_j\f$ and corresponding matrices \f$B_j\f$,
|
|
using the QR factorizations computed by ``GEQRF_STRIDED_BATCHED``
|
|
(or the LQ factorizations computed by ``GELQF_STRIDED_BATCHED``).
|
|
|
|
For each instance in the batch, depending on the value of ``trans``, the problem solved by this function is either of the form:
|
|
|
|
\f[
|
|
\begin{array}{cl}
|
|
A_j X_j = B_j & \: \text{not transposed, or}\\
|
|
A_j' X_j = B_j & \: \text{transposed if real, or conjugate transposed if complex}
|
|
\end{array}
|
|
\f]
|
|
|
|
If ``m >= n`` (or ``m < n`` in the case of transpose/conjugate transpose), the system is overdetermined
|
|
and a least-squares solution approximating ``X_j`` is found by minimizing:
|
|
|
|
\f[
|
|
|| B_j - A_j X_j || \quad \text{(or} \: || B_j - A_j' X_j ||\text{)}
|
|
\f]
|
|
|
|
If ``m < n`` (or ``m >= n`` in the case of transpose/conjugate transpose), the system is underdetermined
|
|
and a unique solution for ``X_j`` is chosen such that \f$|| X_j ||\f$ is minimal.
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
trans hipblasOperation_t.
|
|
Specifies the form of the system of equations.
|
|
@param[in]
|
|
m int. m >= 0.
|
|
The number of rows of all matrices A_j in the batch.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The number of columns of all matrices A_j in the batch.
|
|
@param[in]
|
|
nrhs int. nrhs >= 0.
|
|
The number of columns of all matrices B_j and X_j in the batch,
|
|
that is, the columns on the right hand side.
|
|
@param[inout]
|
|
A pointer to type. Array on the GPU (the size depends on the value of strideA).
|
|
- On entry, the matrices A_j.
|
|
- On exit, the QR (or LQ) factorizations of A_j as returned by "GEQRF_STRIDED_BATCHED"
|
|
(or "GELQF_STRIDED_BATCHED").
|
|
@param[in]
|
|
lda int. lda >= m.
|
|
Specifies the leading dimension of matrices A_j.
|
|
@param[in]
|
|
strideA hipblasStride.
|
|
Stride from the start of one matrix A_j to the next one A_(j+1).
|
|
There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
|
|
@param[inout]
|
|
B pointer to type. Array on the GPU (the size depends on the value of strideB).
|
|
- On entry, the matrices B_j.
|
|
- On exit, when info[j] = 0, each B_j is overwritten by the solution vectors (and the residuals in
|
|
the overdetermined cases) stored as columns.
|
|
@param[in]
|
|
ldb int. ldb >= max(m,n).
|
|
Specifies the leading dimension of matrices B_j.
|
|
@param[in]
|
|
strideB hipblasStride.
|
|
Stride from the start of one matrix B_j to the next one B_(j+1).
|
|
There is no restriction for the value of strideB. Normal use case is strideB >= ldb*nrhs.
|
|
@param[out]
|
|
info pointer to an int on the host.
|
|
- If info = 0, successful exit.
|
|
- If info = j < 0, the argument at position -j is invalid.
|
|
@param[out]
|
|
deviceInfo pointer to int. Array of batchCount integers on the GPU.
|
|
- If deviceInfo[j] = 0, successful exit for solution of A_j.
|
|
- If deviceInfo[j] = i > 0, the solution of A_j could not be computed because input
|
|
matrix A_j is rank deficient; the i-th diagonal element of its triangular factor is zero.
|
|
@param[in]
|
|
batchCount int. batchCount >= 0.
|
|
Number of matrices in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgelsStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
float* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
float* B,
|
|
const int ldb,
|
|
const hipblasStride strideB,
|
|
int* info,
|
|
int* deviceInfo,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgelsStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
double* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
double* B,
|
|
const int ldb,
|
|
const hipblasStride strideB,
|
|
int* info,
|
|
int* deviceInfo,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgelsStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
hipComplex* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
hipComplex* B,
|
|
const int ldb,
|
|
const hipblasStride strideB,
|
|
int* info,
|
|
int* deviceInfo,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgelsStridedBatched(hipblasHandle_t handle,
|
|
hipblasOperation_t trans,
|
|
const int m,
|
|
const int n,
|
|
const int nrhs,
|
|
hipDoubleComplex* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
hipDoubleComplex* B,
|
|
const int ldb,
|
|
const hipblasStride strideB,
|
|
int* info,
|
|
int* deviceInfo,
|
|
const int batchCount);
|
|
///@}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The geqrf functions compute a QR factorization of a general ``m``-by-``n`` matrix ``A``. The factorization has the form:
|
|
|
|
\f[
|
|
A = Q\left[\begin{array}{c}
|
|
R\\
|
|
0
|
|
\end{array}\right]
|
|
\f]
|
|
|
|
where ``R`` is upper triangular (upper trapezoidal if ``m < n``), and ``Q`` is
|
|
an ``m``-by-``m`` orthogonal/unitary matrix represented as the product of Householder matrices:
|
|
|
|
\f[
|
|
Q = H_1H_2\cdots H_k, \quad \text{with} \: k = \text{min}(m,n)
|
|
\f]
|
|
|
|
Each Householder matrix \f$H_i\f$ is given by:
|
|
|
|
\f[
|
|
H_i = I - \text{ipiv}[i] \cdot v_i v_i'
|
|
\f]
|
|
|
|
where the first ``i``-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
m int. m >= 0.
|
|
The number of rows of the matrix A.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The number of columns of the matrix A.
|
|
@param[inout]
|
|
A pointer to type. Array on the GPU of dimension lda*n.
|
|
- On entry, the m-by-n matrix to be factored.
|
|
- On exit, the elements on and above the diagonal contain the
|
|
factor R. The elements below the diagonal are the last m - i elements
|
|
of Householder vector v_i.
|
|
@param[in]
|
|
lda int. lda >= m.
|
|
Specifies the leading dimension of A.
|
|
@param[out]
|
|
ipiv pointer to type. Array on the GPU of dimension min(m,n).
|
|
The Householder scalars.
|
|
@param[out]
|
|
info pointer to a int on the host.
|
|
- If info = 0, successful exit.
|
|
- If info = j < 0, the argument at position -j is invalid.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgeqrf(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
float* A,
|
|
const int lda,
|
|
float* ipiv,
|
|
int* info);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgeqrf(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
double* A,
|
|
const int lda,
|
|
double* ipiv,
|
|
int* info);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeqrf(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
hipComplex* A,
|
|
const int lda,
|
|
hipComplex* ipiv,
|
|
int* info);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeqrf(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
hipDoubleComplex* A,
|
|
const int lda,
|
|
hipDoubleComplex* ipiv,
|
|
int* info);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The geqrfBatched function computes the QR factorization of a batch of general
|
|
``m``-by-``n`` matrices.
|
|
|
|
The factorization of matrix \f$A_i\f$ in the batch has the form:
|
|
|
|
\f[
|
|
A_i = Q_i\left[\begin{array}{c}
|
|
R_i\\
|
|
0
|
|
\end{array}\right]
|
|
\f]
|
|
|
|
where \f$R_i\f$ is upper triangular (upper trapezoidal if ``m`` < ``n``) and \f$Q_i\f$ is
|
|
an ``m``-by-``m`` orthogonal/unitary matrix represented as the product of Householder matrices:
|
|
|
|
\f[
|
|
Q_i = H_{i_1}H_{i_2}\cdots H_{i_k}, \quad \text{with} \: k = \text{min}(m,n)
|
|
\f]
|
|
|
|
Each Householder matrix \f$H_{i_j}\f$ is given by:
|
|
|
|
\f[
|
|
H_{i_j} = I - \text{ipiv}_i[j] \cdot v_{i_j} v_{i_j}'
|
|
\f]
|
|
|
|
where the first ``j``-1 elements of Householder vector \f$v_{i_j}\f$ are zero and \f$v_{i_j}[j] = 1\f$.
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``.
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
m int. m >= 0.
|
|
The number of rows of all the matrices A_i in the batch.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The number of columns of all the matrices A_i in the batch.
|
|
@param[inout]
|
|
A Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
|
|
- On entry, the m-by-n matrices A_i to be factored.
|
|
- On exit, the elements on and above the diagonal contain the
|
|
factor R_i. The elements below the diagonal are the last m - j elements
|
|
of Householder vector v_(i_j).
|
|
@param[in]
|
|
lda int. lda >= m.
|
|
Specifies the leading dimension of matrices A_i.
|
|
@param[out]
|
|
ipiv array of pointers to type. Each pointer points to an array on the GPU
|
|
of dimension min(m, n).
|
|
Contains the vectors ipiv_i of corresponding Householder scalars.
|
|
@param[out]
|
|
info pointer to a int on the host.
|
|
- If info = 0, successful exit.
|
|
- If info = j < 0, the argument at position -j is invalid.
|
|
@param[in]
|
|
batchCount int. batchCount >= 0.
|
|
Number of matrices in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgeqrfBatched(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
float* const A[],
|
|
const int lda,
|
|
float* const ipiv[],
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgeqrfBatched(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
double* const A[],
|
|
const int lda,
|
|
double* const ipiv[],
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeqrfBatched(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
hipComplex* const A[],
|
|
const int lda,
|
|
hipComplex* const ipiv[],
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeqrfBatched(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
hipDoubleComplex* const A[],
|
|
const int lda,
|
|
hipDoubleComplex* const ipiv[],
|
|
int* info,
|
|
const int batchCount);
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> SOLVER API </b>
|
|
|
|
\details
|
|
The geqrfStridedBatched functions compute the QR factorization of a batch of
|
|
general ``m``-by-``n`` matrices.
|
|
|
|
The factorization of matrix \f$A_i\f$ in the batch has the form:
|
|
|
|
\f[
|
|
A_i = Q_i\left[\begin{array}{c}
|
|
R_i\\
|
|
0
|
|
\end{array}\right]
|
|
\f]
|
|
|
|
where \f$R_i\f$ is upper triangular (upper trapezoidal if ``m`` < ``n``), and \f$Q_i\f$ is
|
|
an ``m``-by-``m`` orthogonal/unitary matrix represented as the product of Householder matrices:
|
|
|
|
\f[
|
|
Q_i = H_{i_1}H_{i_2}\cdots H_{i_k}, \quad \text{with} \: k = \text{min}(m,n)
|
|
\f]
|
|
|
|
Each Householder matrix \f$H_{i_j}\f$ is given by:
|
|
|
|
\f[
|
|
H_{i_j} = I - \text{ipiv}_j[j] \cdot v_{i_j} v_{i_j}'
|
|
\f]
|
|
|
|
where the first ``j``-1 elements of Householder vector \f$v_{i_j}\f$ are zero, and \f$v_{i_j}[j] = 1\f$.
|
|
|
|
- Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``.
|
|
- Supported precisions in cuBLAS : No support.
|
|
|
|
@param[in]
|
|
handle hipblasHandle_t.
|
|
@param[in]
|
|
m int. m >= 0.
|
|
The number of rows of all the matrices A_i in the batch.
|
|
@param[in]
|
|
n int. n >= 0.
|
|
The number of columns of all the matrices A_i in the batch.
|
|
@param[inout]
|
|
A pointer to type. Array on the GPU (the size depends on the value of strideA).
|
|
- On entry, the m-by-n matrices A_i to be factored.
|
|
- On exit, the elements on and above the diagonal contain the
|
|
factor R_i. The elements below the diagonal are the last m - j elements
|
|
of Householder vector v_(i_j).
|
|
@param[in]
|
|
lda int. lda >= m.
|
|
Specifies the leading dimension of matrices A_i.
|
|
@param[in]
|
|
strideA hipblasStride.
|
|
Stride from the start of one matrix A_i to the next one A_(i+1).
|
|
There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
|
|
@param[out]
|
|
ipiv pointer to type. Array on the GPU (the size depends on the value of strideP).
|
|
Contains the vectors ipiv_i of corresponding Householder scalars.
|
|
@param[in]
|
|
strideP hipblasStride.
|
|
Stride from the start of one vector ipiv_i to the next one ipiv_(i+1).
|
|
There is no restriction for the value
|
|
of strideP. Normal use is strideP >= min(m,n).
|
|
@param[out]
|
|
info pointer to a int on the host.
|
|
- If info = 0, successful exit.
|
|
- If info = j < 0, the argument at position -j is invalid.
|
|
@param[in]
|
|
batchCount int. batchCount >= 0.
|
|
Number of matrices in the batch.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSgeqrfStridedBatched(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
float* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
float* ipiv,
|
|
const hipblasStride strideP,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDgeqrfStridedBatched(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
double* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
double* ipiv,
|
|
const hipblasStride strideP,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasCgeqrfStridedBatched(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
hipComplex* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
hipComplex* ipiv,
|
|
const hipblasStride strideP,
|
|
int* info,
|
|
const int batchCount);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasZgeqrfStridedBatched(hipblasHandle_t handle,
|
|
const int m,
|
|
const int n,
|
|
hipDoubleComplex* A,
|
|
const int lda,
|
|
const hipblasStride strideA,
|
|
hipDoubleComplex* ipiv,
|
|
const hipblasStride strideP,
|
|
int* info,
|
|
const int batchCount);
|
|
//! @}
|
|
|
|
/*
|
|
* ===========================================================================
|
|
* BLAS Extensions
|
|
* ===========================================================================
|
|
*/
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The gemmEx functions perform one of the matrix-matrix operations:
|
|
|
|
C = alpha*op( A )*op( B ) + beta*C,
|
|
|
|
where ``op( X )`` is one of:
|
|
|
|
op( X ) = X or
|
|
op( X ) = X**T or
|
|
op( X ) = X**H,
|
|
|
|
``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are matrices, with
|
|
``op( A )`` an ``m`` by ``k`` matrix, ``op( B )`` a ``k`` by ``n`` matrix, and ``C`` an ``m`` by ``n`` matrix.
|
|
|
|
- Supported types are determined by the backend. See the cuBLAS documentation for cuBLAS backend information.
|
|
For the rocBLAS backend, conversion from ``hipblasComputeType_t`` to ``rocblas_datatype_t`` happens within hipBLAS.
|
|
Supported types are as follows:
|
|
|
|
| aType | bType | cType | computeType |
|
|
| ---------- | ---------- | ---------- | ------------------- |
|
|
| HIP_R_16F | HIP_R_16F | HIP_R_16F | HIPBLAS_COMPUTE_16F |
|
|
| HIP_R_16F | HIP_R_16F | HIP_R_16F | HIPBLAS_COMPUTE_32F |
|
|
| HIP_R_16F | HIP_R_16F | HIP_R_32F | HIPBLAS_COMPUTE_32F |
|
|
| HIP_R_16BF | HIP_R_16BF | HIP_R_16BF | HIPBLAS_COMPUTE_32F |
|
|
| HIP_R_16BF | HIP_R_16BF | HIP_R_32F | HIPBLAS_COMPUTE_32F |
|
|
| HIP_R_32F | HIP_R_32F | HIP_R_32F | HIPBLAS_COMPUTE_32F |
|
|
| HIP_R_64F | HIP_R_64F | HIP_R_64F | HIPBLAS_COMPUTE_64F |
|
|
| HIP_R_8I | HIP_R_8I | HIP_R_32I | HIPBLAS_COMPUTE_32I |
|
|
| HIP_C_32F | HIP_C_32F | HIP_C_32F | HIPBLAS_COMPUTE_32F |
|
|
| HIP_C_64F | HIP_C_64F | HIP_C_64F | HIPBLAS_COMPUTE_64F |
|
|
|
|
``hipblasGemmExWithFlags`` is also available. This is identical to ``hipblasGemmEx``
|
|
with the addition of a ``flags`` parameter which controls the flags used in Tensile to control gemm algorithms with the
|
|
rocBLAS backend. When using a cuBLAS backend, this parameter is ignored.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
specifies the form of op( A ).
|
|
@param[in]
|
|
transB [hipblasOperation_t]
|
|
specifies the form of op( B ).
|
|
@param[in]
|
|
m [int]
|
|
matrix dimension m.
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
k [int]
|
|
matrix dimension k.
|
|
@param[in]
|
|
alpha [const void *]
|
|
device pointer or host pointer specifying the scalar alpha. Same datatype as computeType.
|
|
@param[in]
|
|
A [void *]
|
|
device pointer storing matrix A.
|
|
@param[in]
|
|
aType
|
|
[hipDataType]
|
|
specifies the datatype of matrix A.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
@param[in]
|
|
B [void *]
|
|
device pointer storing matrix B.
|
|
@param[in]
|
|
bType
|
|
[hipDataType]
|
|
specifies the datatype of matrix B.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of B.
|
|
@param[in]
|
|
beta [const void *]
|
|
device pointer or host pointer specifying the scalar beta. Same datatype as computeType.
|
|
@param[in]
|
|
C [void *]
|
|
device pointer storing matrix C.
|
|
@param[in]
|
|
cType
|
|
[hipDataType]
|
|
specifies the datatype of matrix C.
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of C.
|
|
@param[in]
|
|
computeType
|
|
[hipblasComputeType_t]
|
|
specifies the datatype of computation.
|
|
@param[in]
|
|
algo [hipblasGemmAlgo_t]
|
|
enumerant specifying the algorithm type.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGemmEx(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
int lda,
|
|
const void* B,
|
|
hipDataType bType,
|
|
int ldb,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
int ldc,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGemmExWithFlags(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
int lda,
|
|
const void* B,
|
|
hipDataType bType,
|
|
int ldb,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
int ldc,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo,
|
|
hipblasGemmFlags_t flags);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGemmEx_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
int64_t lda,
|
|
const void* B,
|
|
hipDataType bType,
|
|
int64_t ldb,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
int64_t ldc,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGemmExWithFlags_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
int64_t lda,
|
|
const void* B,
|
|
hipDataType bType,
|
|
int64_t ldb,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
int64_t ldc,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo,
|
|
hipblasGemmFlags_t flags);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The gemmBatchedEx functions perform one of the batched matrix-matrix operations:
|
|
|
|
C_i = alpha*op(A_i)*op(B_i) + beta*C_i, for i = 1, ..., batchCount.
|
|
|
|
where ``op( X )`` is one of:
|
|
|
|
op( X ) = X or
|
|
op( X ) = X**T or
|
|
op( X ) = X**H,
|
|
|
|
``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are batched pointers to matrices, with
|
|
``op( A )`` an ``m`` by ``k`` by ``batchCount`` batched matrix,
|
|
``op( B )`` a ``k`` by ``n`` by ``batchCount`` batched matrix, and
|
|
``C`` an ``m`` by ``n`` by ``batchCount`` batched matrix.
|
|
The batched matrices are an array of pointers to matrices.
|
|
The number of pointers to matrices is ``batchCount``.
|
|
|
|
- Supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
``hipblasGemmBatchedExWithFlags`` is also available. This is identical to ``hipblasGemmBatchedEx``
|
|
with the addition of a ``flags`` parameter which controls the flags used in Tensile to control gemm algorithms with the
|
|
rocBLAS backend. When using a cuBLAS backend, this parameter is ignored.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
specifies the form of op( A ).
|
|
@param[in]
|
|
transB [hipblasOperation_t]
|
|
specifies the form of op( B ).
|
|
@param[in]
|
|
m [int]
|
|
matrix dimension m.
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
k [int]
|
|
matrix dimension k.
|
|
@param[in]
|
|
alpha [const void *]
|
|
device pointer or host pointer specifying the scalar alpha. Same datatype as computeType.
|
|
@param[in]
|
|
A [void *]
|
|
device pointer storing array of pointers to each matrix A_i.
|
|
@param[in]
|
|
aType
|
|
[hipDataType]
|
|
specifies the datatype of each matrix A_i.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[in]
|
|
B [void *]
|
|
device pointer storing array of pointers to each matrix B_i.
|
|
@param[in]
|
|
bType
|
|
[hipDataType]
|
|
specifies the datatype of each matrix B_i.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of each B_i.
|
|
@param[in]
|
|
beta [const void *]
|
|
device pointer or host pointer specifying the scalar beta. Same datatype as computeType.
|
|
@param[in]
|
|
C [void *]
|
|
device array of device pointers to each matrix C_i.
|
|
@param[in]
|
|
cType
|
|
[hipDataType]
|
|
specifies the datatype of each matrix C_i.
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of each C_i.
|
|
@param[in]
|
|
batchCount
|
|
[int]
|
|
number of gemm operations in the batch.
|
|
@param[in]
|
|
computeType
|
|
[hipblasComputeType_t]
|
|
specifies the datatype of computation.
|
|
@param[in]
|
|
algo [hipblasGemmAlgo_t]
|
|
enumerant specifying the algorithm type.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGemmBatchedEx(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const void* alpha,
|
|
const void* A[],
|
|
hipDataType aType,
|
|
int lda,
|
|
const void* B[],
|
|
hipDataType bType,
|
|
int ldb,
|
|
const void* beta,
|
|
void* C[],
|
|
hipDataType cType,
|
|
int ldc,
|
|
int batchCount,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGemmBatchedExWithFlags(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const void* alpha,
|
|
const void* A[],
|
|
hipDataType aType,
|
|
int lda,
|
|
const void* B[],
|
|
hipDataType bType,
|
|
int ldb,
|
|
const void* beta,
|
|
void* C[],
|
|
hipDataType cType,
|
|
int ldc,
|
|
int batchCount,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo,
|
|
hipblasGemmFlags_t flags);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGemmBatchedEx_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const void* alpha,
|
|
const void* A[],
|
|
hipDataType aType,
|
|
int64_t lda,
|
|
const void* B[],
|
|
hipDataType bType,
|
|
int64_t ldb,
|
|
const void* beta,
|
|
void* C[],
|
|
hipDataType cType,
|
|
int64_t ldc,
|
|
int64_t batchCount,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGemmBatchedExWithFlags_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const void* alpha,
|
|
const void* A[],
|
|
hipDataType aType,
|
|
int64_t lda,
|
|
const void* B[],
|
|
hipDataType bType,
|
|
int64_t ldb,
|
|
const void* beta,
|
|
void* C[],
|
|
hipDataType cType,
|
|
int64_t ldc,
|
|
int64_t batchCount,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo,
|
|
hipblasGemmFlags_t flags);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The gemmStridedBatchedEx functions perform one of the strided_batched matrix-matrix operations:
|
|
|
|
C_i = alpha*op(A_i)*op(B_i) + beta*C_i, for i = 1, ..., batchCount
|
|
|
|
where ``op( X )`` is one of:
|
|
|
|
op( X ) = X or
|
|
op( X ) = X**T or
|
|
op( X ) = X**H,
|
|
|
|
``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are strided_batched matrices, with
|
|
``op( A )`` an ``m`` by ``k`` by ``batchCount`` strided_batched matrix,
|
|
``op( B )`` a ``k`` by ``n`` by ``batchCount`` strided_batched matrix, and
|
|
``C`` an ``m`` by ``n`` by ``batchCount`` strided_batched matrix.
|
|
|
|
The strided_batched matrices are multiple matrices separated by a constant stride.
|
|
The number of matrices is ``batchCount``.
|
|
|
|
- Supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
``hipblasGemmStridedBatchedExWithFlags`` is also available. This is identical to ``hipblasStridedBatchedGemmEx``
|
|
with the addition of a ``flags`` parameter which controls the flags used in Tensile to control gemm algorithms with the
|
|
rocBLAS backend. When using a cuBLAS backend, this parameter is ignored.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
specifies the form of op( A ).
|
|
@param[in]
|
|
transB [hipblasOperation_t]
|
|
specifies the form of op( B ).
|
|
@param[in]
|
|
m [int]
|
|
matrix dimension m.
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
k [int]
|
|
matrix dimension k.
|
|
@param[in]
|
|
alpha [const void *]
|
|
device pointer or host pointer specifying the scalar alpha. Same datatype as computeType.
|
|
@param[in]
|
|
A [void *]
|
|
device pointer pointing to first matrix A_1.
|
|
@param[in]
|
|
aType
|
|
[hipDataType]
|
|
specifies the datatype of each matrix A_i.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of each A_i.
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
specifies stride from start of one A_i matrix to the next A_(i + 1).
|
|
@param[in]
|
|
B [void *]
|
|
device pointer pointing to first matrix B_1.
|
|
@param[in]
|
|
bType
|
|
[hipDataType]
|
|
specifies the datatype of each matrix B_i.
|
|
@param[in]
|
|
ldb [int]
|
|
specifies the leading dimension of each B_i.
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
specifies stride from start of one B_i matrix to the next B_(i + 1).
|
|
@param[in]
|
|
beta [const void *]
|
|
device pointer or host pointer specifying the scalar beta. Same datatype as computeType.
|
|
@param[in]
|
|
C [void *]
|
|
device pointer pointing to first matrix C_1.
|
|
@param[in]
|
|
cType
|
|
[hipDataType]
|
|
specifies the datatype of each matrix C_i.
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of each C_i.
|
|
@param[in]
|
|
strideC [hipblasStride]
|
|
specifies stride from start of one C_i matrix to the next C_(i + 1).
|
|
@param[in]
|
|
batchCount
|
|
[int]
|
|
number of gemm operations in the batch.
|
|
@param[in]
|
|
computeType
|
|
[hipblasComputeType_t]
|
|
specifies the datatype of computation.
|
|
@param[in]
|
|
algo [hipblasGemmAlgo_t]
|
|
enumerant specifying the algorithm type.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGemmStridedBatchedEx(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const void* B,
|
|
hipDataType bType,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasGemmStridedBatchedExWithFlags(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int m,
|
|
int n,
|
|
int k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
const void* B,
|
|
hipDataType bType,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
int ldc,
|
|
hipblasStride strideC,
|
|
int batchCount,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo,
|
|
hipblasGemmFlags_t flags);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasGemmStridedBatchedEx_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const void* B,
|
|
hipDataType bType,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t
|
|
hipblasGemmStridedBatchedExWithFlags_64(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
int64_t m,
|
|
int64_t n,
|
|
int64_t k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
int64_t lda,
|
|
hipblasStride strideA,
|
|
const void* B,
|
|
hipDataType bType,
|
|
int64_t ldb,
|
|
hipblasStride strideB,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
int64_t ldc,
|
|
hipblasStride strideC,
|
|
int64_t batchCount,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo,
|
|
hipblasGemmFlags_t flags);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
|
|
The syrkEx function performs one of the matrix-matrix operations for a symmetric rank-k update:
|
|
|
|
C := alpha*op( A )*op( A )^T + beta*C
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and
|
|
``C`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower.
|
|
|
|
op( A ) = A, and A is n by k if transA == HIPBLAS_OP_N
|
|
op( A ) = A^T and A is k by n if transA == HIPBLAS_OP_T
|
|
|
|
- Supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
Specifies whether the matrix C is an upper or lower triangular matrix as follows:
|
|
- HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
specifies the form of op( A ).
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
k [int]
|
|
matrix dimension k.
|
|
@param[in]
|
|
alpha [const void *]
|
|
device pointer or host pointer specifying the scalar alpha. Same datatype as computeType.
|
|
@param[in]
|
|
A [void *]
|
|
device pointer storing matrix A.
|
|
@param[in]
|
|
aType
|
|
[hipDataType]
|
|
specifies the datatype of matrix A.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
@param[in]
|
|
beta [const void *]
|
|
device pointer or host pointer specifying the scalar beta. Same datatype as computeType.
|
|
@param[in]
|
|
C [void *]
|
|
device pointer storing matrix C.
|
|
@param[in]
|
|
cType
|
|
[hipDataType]
|
|
specifies the datatype of matrix C.
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of C.
|
|
@param[in]
|
|
computeType
|
|
[hipDataType]
|
|
specifies the datatype of the computation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasSyrkEx(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
int lda,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
int ldc,
|
|
hipDataType computeType);
|
|
|
|
/*! <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The trsmEx functions solve:
|
|
|
|
op(A)*X = alpha*B or X*op(A) = alpha*B,
|
|
|
|
where ``alpha`` is a scalar, ``X`` and ``B`` are ``m`` by ``n`` matrices,
|
|
``A`` is a triangular matrix, and ``op(A)`` is one of
|
|
|
|
op( A ) = A or op( A ) = A^T or op( A ) = A^H.
|
|
|
|
The matrix ``X`` is overwritten on ``B``.
|
|
|
|
This function gives the user the ability to reuse the ``invA`` matrix between runs.
|
|
If ``invA == NULL``, ``hipblasTrsmEx`` will automatically calculate ``invA`` on every run.
|
|
|
|
Setting up invA:
|
|
The accepted ``invA`` matrix consists of the packed 128x128 inverses of the diagonal blocks of
|
|
matrix ``A``, followed by any smaller diagonal block that remains.
|
|
To set up ``invA``, it is recommended that ``hipblasTrtriBatched`` be used with matrix ``A`` as the input.
|
|
|
|
Device memory of size 128 x ``k`` should be allocated for ``invA`` ahead of time, where ``k`` is ``m`` when
|
|
``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``. The actual number of elements in ``invA``
|
|
should be passed as ``invAsize``.
|
|
|
|
To begin, ``hipblasTrtriBatched`` must be called on the full 128x128 sized diagonal blocks of
|
|
matrix ``A``. Here are the restricted parameters:
|
|
- ``n`` = 128
|
|
- ``ldinvA`` = 128
|
|
- ``stride_invA`` = 128x128
|
|
- ``batchCount`` = ``k / 128``,
|
|
|
|
Then any remaining block can be added:
|
|
- ``n`` = ``k % 128``
|
|
- ``invA`` = ``invA + stride_invA * previousBatchCount``
|
|
- ``ldinvA`` = 128
|
|
- ``batchCount`` = 1
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B.
|
|
- HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: op(A) = A.
|
|
- HIPBLAS_OP_T: op(A) = A^T.
|
|
- HIPBLAS_ON_C: op(A) = A^H.
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of B. m >= 0.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of B. n >= 0.
|
|
|
|
@param[in]
|
|
alpha [void *]
|
|
device pointer or host pointer specifying the scalar alpha. When alpha is
|
|
&zero, then A is not referenced, and B does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
A [void *]
|
|
device pointer storing matrix A.
|
|
Of dimension ( lda, k ), where k is m
|
|
when HIPBLAS_SIDE_LEFT and
|
|
is n when HIPBLAS_SIDE_RIGHT.
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
- If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
- If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ).
|
|
|
|
@param[in, out]
|
|
B [void *]
|
|
device pointer storing matrix B.
|
|
B is of dimension ( ldb, n ).
|
|
Before entry, the leading m by n part of the array B must
|
|
contain the right-hand side matrix B, and on exit is
|
|
overwritten by the solution matrix X.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of B. ldb >= max( 1, m ).
|
|
|
|
@param[in]
|
|
invA [void *]
|
|
device pointer storing the inverse diagonal blocks of A.
|
|
invA is of dimension ( ld_invA, k ), where k is m
|
|
when HIPBLAS_SIDE_LEFT and
|
|
is n when HIPBLAS_SIDE_RIGHT.
|
|
ld_invA must be equal to 128.
|
|
|
|
@param[in]
|
|
invAsize [int]
|
|
invAsize specifies the number of elements of device memory in invA.
|
|
|
|
@param[in]
|
|
computeType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasTrsmEx(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const void* alpha,
|
|
void* A,
|
|
int lda,
|
|
void* B,
|
|
int ldb,
|
|
const void* invA,
|
|
int invAsize,
|
|
hipDataType computeType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
|
|
The herkEx function performs one of the matrix-matrix operations for a Hermitian rank-k update:
|
|
|
|
C := alpha*op( A )*op( A )^H + beta*C
|
|
|
|
where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and
|
|
``C`` is a Hermitian ``n`` x ``n`` matrix stored as either upper or lower.
|
|
|
|
op( A ) = A, and A is n by k if transA == HIPBLAS_OP_N
|
|
op( A ) = A^H and A is k by n if transA == HIPBLAS_OP_C
|
|
|
|
- Supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
Specifies whether the matrix C is an upper or lower triangular matrix as follows:
|
|
- HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix.
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
specifies the form of op( A ).
|
|
@param[in]
|
|
n [int]
|
|
matrix dimension n.
|
|
@param[in]
|
|
k [int]
|
|
matrix dimension k.
|
|
@param[in]
|
|
alpha [const void *]
|
|
device pointer or host pointer specifying the scalar alpha. Same datatype as computeType.
|
|
@param[in]
|
|
A [void *]
|
|
device pointer storing matrix A.
|
|
@param[in]
|
|
aType
|
|
[hipDataType]
|
|
specifies the datatype of matrix A.
|
|
@param[in]
|
|
lda [int]
|
|
specifies the leading dimension of A.
|
|
@param[in]
|
|
beta [const void *]
|
|
device pointer or host pointer specifying the scalar beta. Same datatype as computeType.
|
|
@param[in]
|
|
C [void *]
|
|
device pointer storing matrix C.
|
|
@param[in]
|
|
cType
|
|
[hipDataType]
|
|
specifies the datatype of matrix C.
|
|
@param[in]
|
|
ldc [int]
|
|
specifies the leading dimension of C.
|
|
@param[in]
|
|
computeType
|
|
[hipDataType]
|
|
specifies the datatype of the computation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasHerkEx(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
int n,
|
|
int k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
int lda,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
int ldc,
|
|
hipDataType computeType);
|
|
|
|
/*! <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The trsmBatchedEx functions solve:
|
|
|
|
op(A_i)*X_i = alpha*B_i or X_i*op(A_i) = alpha*B_i,
|
|
|
|
for ``i`` = 1, ..., ``batchCount``, where ``alpha`` is a scalar, ``X`` and ``B`` are arrays of ``m`` by ``n`` matrices,
|
|
``A`` is an array of triangular matrices, and each ``op(A_i)`` is one of:
|
|
|
|
op( A_i ) = A_i or op( A_i ) = A_i^T or op( A_i ) = A_i^H.
|
|
|
|
Each matrix ``X_i`` is overwritten on ``B_i``.
|
|
|
|
This function gives the user the ability to reuse the ``invA`` matrix between runs.
|
|
If ``invA == NULL``, ``hipblasTrsmBatchedEx`` will automatically calculate each ``invA_i`` on every run.
|
|
|
|
Setting up ``invA``:
|
|
Each accepted ``invA_i`` matrix consists of the packed 128x128 inverses of the diagonal blocks of
|
|
matrix ``A_i``, followed by any smaller diagonal block that remains.
|
|
To set up each ``invA_i``, it is recommended that ``hipblasTrtriBatched`` be used with matrix ``A_i`` as the input.
|
|
``invA`` is an array of pointers of ``batchCount`` length holding each ``invA_i``.
|
|
|
|
Device memory of size 128 x ``k`` should be allocated for each ``invA_i`` ahead of time, where ``k`` is ``m`` when
|
|
``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``. The actual number of elements in each ``invA_i``
|
|
should be passed as ``invAsize``.
|
|
|
|
To begin, ``hipblasTrtriBatched`` must be called on the full 128x128 sized diagonal blocks of each
|
|
matrix ``A_i``. Below are the restricted parameters:
|
|
- ``n`` = 128
|
|
- ``ldinvA`` = 128
|
|
- ``stride_invA`` = 128x128
|
|
- ``batchCount`` = ``k / 128``,
|
|
|
|
Then any remaining block can be added:
|
|
- ``n`` = ``k % 128``
|
|
- ``invA`` = ``invA + stride_invA * previousBatchCount``
|
|
- ``ldinvA`` = 128
|
|
- ``batchCount`` = 1
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B.
|
|
- HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: op(A) = A.
|
|
- HIPBLAS_OP_T: op(A) = A^T.
|
|
- HIPBLAS_OP_C: op(A) = A^H.
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of each B_i. m >= 0.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of each B_i. n >= 0.
|
|
|
|
@param[in]
|
|
alpha [void *]
|
|
device pointer or host pointer alpha specifying the scalar alpha. When alpha is
|
|
&zero, then A is not referenced, and B does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
A [void *]
|
|
device array of device pointers storing each matrix A_i.
|
|
Each A_i is of dimension ( lda, k ), where k is m
|
|
when HIPBLAS_SIDE_LEFT and
|
|
is n when HIPBLAS_SIDE_RIGHT.
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of each A_i.
|
|
- If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
- If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ).
|
|
|
|
@param[in, out]
|
|
B [void *]
|
|
device array of device pointers storing each matrix B_i.
|
|
Each B_i is of dimension ( ldb, n ).
|
|
Before entry, the leading m by n part of the array B_i must
|
|
contain the right-hand side matrix B_i, and on exit is
|
|
overwritten by the solution matrix X_i.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of each B_i. ldb >= max( 1, m ).
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
specifies how many batches.
|
|
|
|
@param[in]
|
|
invA [void *]
|
|
device array of device pointers storing the inverse diagonal blocks of each A_i.
|
|
Each invA_i is of dimension ( ld_invA, k ), where k is m
|
|
when HIPBLAS_SIDE_LEFT and
|
|
is n when HIPBLAS_SIDE_RIGHT.
|
|
ld_invA must be equal to 128.
|
|
|
|
@param[in]
|
|
invAsize [int]
|
|
invAsize specifies the number of elements of device memory in each invA_i.
|
|
|
|
@param[in]
|
|
computeType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasTrsmBatchedEx(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const void* alpha,
|
|
void* A,
|
|
int lda,
|
|
void* B,
|
|
int ldb,
|
|
int batchCount,
|
|
const void* invA,
|
|
int invAsize,
|
|
hipDataType computeType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The trsmStridedBatchedEx functions solve:
|
|
|
|
op(A_i)*X_i = alpha*B_i or X_i*op(A_i) = alpha*B_i,
|
|
|
|
for ``i`` = 1, ..., ``batchCount``, where ``alpha`` is a scalar, ``X`` and ``B`` are strided batched ``m`` by ``n`` matrices,
|
|
``A`` is a strided batched triangular matrix, and ``op(A_i)`` is one of:
|
|
|
|
op( A_i ) = A_i or op( A_i ) = A_i^T or op( A_i ) = A_i^H.
|
|
|
|
Each matrix ``X_i`` is overwritten on ``B_i``.
|
|
|
|
This function gives the user the ability to reuse each ``invA_i`` matrix between runs.
|
|
If ``invA == NULL``, ``hipblasTrsmStridedBatchedEx`` will automatically calculate each ``invA_i`` on every run.
|
|
|
|
Setting up invA:
|
|
Each accepted ``invA_i`` matrix consists of the packed 128x128 inverses of the diagonal blocks of
|
|
matrix ``A_i``, followed by any smaller diagonal block that remains.
|
|
To set up ``invA_i``, it is recommended that ``hipblasTrtriBatched`` be used with matrix ``A_i`` as the input.
|
|
``invA`` is a contiguous piece of memory holding each ``invA_i``.
|
|
|
|
Device memory of size 128 x ``k`` should be allocated for each ``invA_i`` ahead of time, where ``k`` is ``m`` when
|
|
``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``. The actual number of elements in each ``invA_i``
|
|
should be passed as ``invAsize``.
|
|
|
|
To begin, ``hipblasTrtriBatched`` must be called on the full 128x128 sized diagonal blocks of each
|
|
matrix ``A_i``. Below are the restricted parameters:
|
|
- ``n`` = 128
|
|
- ``ldinvA`` = 128
|
|
- ``stride_invA`` = 128x128
|
|
- ``batchCount`` = ``k / 128``,
|
|
|
|
Then any remaining block can be added:
|
|
- ``n`` = ``k % 128``
|
|
- ``invA`` = ``invA + stride_invA * previousBatchCount``
|
|
- ``ldinvA`` = 128
|
|
- ``batchCount`` = 1
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
|
|
@param[in]
|
|
side [hipblasSideMode_t]
|
|
- HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B.
|
|
- HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B.
|
|
|
|
@param[in]
|
|
uplo [hipblasFillMode_t]
|
|
- HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix.
|
|
- HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix.
|
|
|
|
@param[in]
|
|
transA [hipblasOperation_t]
|
|
- HIPBLAS_OP_N: op(A) = A.
|
|
- HIPBLAS_OP_T: op(A) = A^T.
|
|
- HIPBLAS_OP_C: op(A) = A^H.
|
|
|
|
@param[in]
|
|
diag [hipblasDiagType_t]
|
|
- HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular.
|
|
- HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular.
|
|
|
|
@param[in]
|
|
m [int]
|
|
m specifies the number of rows of each B_i. m >= 0.
|
|
|
|
@param[in]
|
|
n [int]
|
|
n specifies the number of columns of each B_i. n >= 0.
|
|
|
|
@param[in]
|
|
alpha [void *]
|
|
device pointer or host pointer specifying the scalar alpha. When alpha is
|
|
&zero, then A is not referenced, and B does not need to be set before
|
|
entry.
|
|
|
|
@param[in]
|
|
A [void *]
|
|
device pointer storing matrix A.
|
|
Of dimension ( lda, k ), where k is m
|
|
when HIPBLAS_SIDE_LEFT and
|
|
is n when HIPBLAS_SIDE_RIGHT.
|
|
Only the upper/lower triangular part is accessed.
|
|
|
|
@param[in]
|
|
lda [int]
|
|
lda specifies the first dimension of A.
|
|
- If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ).
|
|
- If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ).
|
|
|
|
@param[in]
|
|
strideA [hipblasStride]
|
|
The stride between each A matrix.
|
|
|
|
@param[in, out]
|
|
B [void *]
|
|
device pointer pointing to first matrix B_i.
|
|
Each B_i is of dimension ( ldb, n ).
|
|
Before entry, the leading m by n part of each array B_i must
|
|
contain the right-hand side of matrix B_i, and on exit is
|
|
overwritten by the solution matrix X_i.
|
|
|
|
@param[in]
|
|
ldb [int]
|
|
ldb specifies the first dimension of each B_i. ldb >= max( 1, m ).
|
|
|
|
@param[in]
|
|
strideB [hipblasStride]
|
|
The stride between each B_i matrix.
|
|
|
|
@param[in]
|
|
batchCount [int]
|
|
specifies how many batches.
|
|
|
|
@param[in]
|
|
invA [void *]
|
|
device pointer storing the inverse diagonal blocks of each A_i.
|
|
invA points to the first invA_1.
|
|
Each invA_i is of dimension ( ld_invA, k ), where k is m
|
|
when HIPBLAS_SIDE_LEFT and
|
|
is n when HIPBLAS_SIDE_RIGHT.
|
|
ld_invA must be equal to 128.
|
|
|
|
@param[in]
|
|
invAsize [int]
|
|
invAsize specifies the number of elements of device memory in each invA_i.
|
|
|
|
@param[in]
|
|
strideInvA [hipblasStride]
|
|
The stride between each invA matrix.
|
|
|
|
@param[in]
|
|
computeType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasTrsmStridedBatchedEx(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
int m,
|
|
int n,
|
|
const void* alpha,
|
|
void* A,
|
|
int lda,
|
|
hipblasStride strideA,
|
|
void* B,
|
|
int ldb,
|
|
hipblasStride strideB,
|
|
int batchCount,
|
|
const void* invA,
|
|
int invAsize,
|
|
hipblasStride strideInvA,
|
|
hipDataType computeType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The axpyEx funtions compute a constant ``alpha`` multiplied by vector ``x``, plus vector ``y``:
|
|
|
|
y := alpha * x + y
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x and y.
|
|
@param[in]
|
|
alpha device pointer or host pointer to specify the scalar alpha.
|
|
@param[in]
|
|
alphaType
|
|
[hipDataType]
|
|
specifies the datatype of alpha.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[inout]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
yType
|
|
[hipDataType]
|
|
specifies the datatype of vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasAxpyEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasAxpyEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
hipDataType executionType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The axpyBatchedEx functions compute a constant ``alpha`` multiplied by vector ``x``, plus vector ``y``, over
|
|
a set of batched vectors.
|
|
|
|
y := alpha * x + y
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i and y_i.
|
|
@param[in]
|
|
alpha device pointer or host pointer to specify the scalar alpha.
|
|
@param[in]
|
|
alphaType
|
|
[hipDataType]
|
|
specifies the datatype of alpha.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[inout]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
yType
|
|
[hipDataType]
|
|
specifies the datatype of each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasAxpyBatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
int batchCount,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasAxpyBatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
int64_t batchCount,
|
|
hipDataType executionType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The axpyStridedBatchedEx functions compute a constant ``alpha`` multiplied by vector ``x``, plus vector ``y``, over
|
|
a set of strided batched vectors.
|
|
|
|
y := alpha * x + y
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i and y_i.
|
|
@param[in]
|
|
alpha device pointer or host pointer to specify the scalar alpha.
|
|
@param[in]
|
|
alphaType
|
|
[hipDataType]
|
|
specifies the datatype of alpha.
|
|
@param[in]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stridex. However, the user should
|
|
ensure that stridex is of an appropriate size. For a typical
|
|
case, this means stridex >= n * incx.
|
|
@param[inout]
|
|
y device pointer to the first vector y_1.
|
|
@param[in]
|
|
yType
|
|
[hipDataType]
|
|
specifies the datatype of each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
There are no restrictions placed on stridey. However, the user should
|
|
ensure that stridey is of appropriate size. For a typical
|
|
case, this means stridey >= n * incy.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasAxpyStridedBatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasAxpyStridedBatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount,
|
|
hipDataType executionType);
|
|
|
|
/*! @{
|
|
\brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The dotEx functions perform the dot product of vectors ``x`` and ``y``:
|
|
|
|
result = x * y;
|
|
|
|
The dotcEx functions perform the dot product of the conjugate of complex vector ``x`` and complex vector ``y``:
|
|
|
|
result = conjugate (x) * y;
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x and y.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of y.
|
|
@param[in]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
yType
|
|
[hipDataType]
|
|
specifies the datatype of vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of y.
|
|
@param[inout]
|
|
result
|
|
device pointer or host pointer to store the dot product.
|
|
Return value is 0.0 if n <= 0.
|
|
@param[in]
|
|
resultType
|
|
[hipDataType]
|
|
specifies the datatype of the result.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotcEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotcEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The dotBatchedEx functions perform a batch of dot products of vectors ``x`` and ``y``:
|
|
|
|
result_i = x_i * y_i;
|
|
|
|
The dotcBatchedEx functions performs a batch of dot products of the conjugate of complex vector ``x`` and complex vector ``y``:
|
|
|
|
result_i = conjugate (x_i) * y_i;
|
|
|
|
where ``(x_i, y_i)`` is the ``i``-th instance of the batch and
|
|
``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i and y_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
yType
|
|
[hipDataType]
|
|
specifies the datatype of each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[inout]
|
|
result
|
|
device array or host array of batchCount size to store the dot products of each batch.
|
|
Returns 0.0 for each element if n <= 0.
|
|
@param[in]
|
|
resultType
|
|
[hipDataType]
|
|
specifies the datatype of the result.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotBatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
int batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotcBatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
int batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotBatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
int64_t batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotcBatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
int64_t batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
//! @}
|
|
|
|
/*! @{
|
|
\brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The dotStridedBatchedEx functions perform a batch of dot products of vectors ``x`` and ``y``:
|
|
|
|
result_i = x_i * y_i;
|
|
|
|
The dotc_strided_batched_ex functions performs a batch of dot products of the conjugate of complex vector ``x`` and complex vector ``y``:
|
|
|
|
result_i = conjugate (x_i) * y_i;
|
|
|
|
where ``(x_i, y_i)`` is the ``i``-th instance of the batch and
|
|
``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ..., ``batchCount``.
|
|
|
|
The supported types are determined by the backend. See rocBLAS/cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in each x_i and y_i.
|
|
@param[in]
|
|
x device pointer to the first vector (x_1) in the batch.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
@param[in]
|
|
y device pointer to the first vector (y_1) in the batch.
|
|
@param[in]
|
|
yType
|
|
[hipDataType]
|
|
specifies the datatype of each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment for the elements of each y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
stride from the start of one vector (y_i) to the next one (y_i+1).
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[inout]
|
|
result
|
|
device array or host array of batchCount size to store the dot products of each batch.
|
|
Returns 0.0 for each element if n <= 0.
|
|
@param[in]
|
|
resultType
|
|
[hipDataType]
|
|
specifies the datatype of the result.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotStridedBatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotcStridedBatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
int batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotStridedBatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasDotcStridedBatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
const void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
int64_t batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
//! @}
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The nrm2Ex functions compute the Euclidean norm of a real or complex vector:
|
|
|
|
result := sqrt( x'*x ) for real vectors
|
|
result := sqrt( x**H*x ) for complex vectors
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x.
|
|
@param[in]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of the vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of y.
|
|
@param[inout]
|
|
result
|
|
device pointer or host pointer to store the nrm2 product.
|
|
The return value is 0.0 if n, incx<=0.
|
|
@param[in]
|
|
resultType
|
|
[hipDataType]
|
|
specifies the datatype of the result.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
********************************************************************/
|
|
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasNrm2Ex(hipblasHandle_t handle,
|
|
int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasNrm2Ex_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The nrm2BatchedEx functions compute the Euclidean norm over a batch of real or complex vectors:
|
|
|
|
result := sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batchCount
|
|
result := sqrt( x_i**H*x_i ) for complex vectors x, for i = 1, ..., batchCount
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each x_i.
|
|
@param[in]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i. incx must be > 0.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[out]
|
|
result
|
|
device pointer or host pointer to array of batchCount size for nrm2 results.
|
|
Returns 0.0 for each element if n <= 0, incx<=0.
|
|
@param[in]
|
|
resultType
|
|
[hipDataType]
|
|
specifies the datatype of the result.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasNrm2BatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
int batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasNrm2BatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The nrm2StridedBatchedEx computes the Euclidean norm over a batch of real or complex vectors:
|
|
|
|
:= sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batchCount
|
|
:= sqrt( x_i**H*x_i ) for complex vectors, for i = 1, ..., batchCount
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each x_i.
|
|
@param[in]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i. incx must be > 0.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) and the next one (x_i+1).
|
|
There are no restrictions placed on stridex. However, the user should
|
|
ensure that stridex is of an appropriate size. For a typical
|
|
case, this means stridex >= n * incx.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[out]
|
|
result
|
|
device pointer or host pointer to array for storing contiguous batchCount results.
|
|
Returns 0.0 for each element if n <= 0, incx<=0.
|
|
@param[in]
|
|
resultType
|
|
[hipDataType]
|
|
specifies the datatype of the result.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasNrm2StridedBatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasNrm2StridedBatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The rotEx functions applies the Givens rotation matrix defined by ``c=cos(alpha)`` and ``s=sin(alpha)`` to vectors ``x`` and ``y``.
|
|
Scalars ``c`` and ``s`` can be stored in either the host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
|
|
If ``cs_type`` is real:
|
|
|
|
x := c * x + s * y
|
|
y := c * y - s * x
|
|
|
|
If ``cs_type`` is complex, the imaginary part of ``c`` is ignored:
|
|
|
|
x := real(c) * x + s * y
|
|
y := real(c) * y - conj(s) * x
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in the x and y vectors.
|
|
@param[inout]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between elements of x.
|
|
@param[inout]
|
|
y device pointer storing vector y.
|
|
@param[in]
|
|
yType
|
|
[hipDataType]
|
|
specifies the datatype of vector y.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment between elements of y.
|
|
@param[in]
|
|
c device pointer or host pointer storing scalar cosine component of the rotation matrix.
|
|
@param[in]
|
|
s device pointer or host pointer storing scalar sine component of the rotation matrix.
|
|
@param[in]
|
|
csType
|
|
[hipDataType]
|
|
specifies the datatype of c and s.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasRotEx(hipblasHandle_t handle,
|
|
int n,
|
|
void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
const void* c,
|
|
const void* s,
|
|
hipDataType csType,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasRotEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
const void* c,
|
|
const void* s,
|
|
hipDataType csType,
|
|
hipDataType executionType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The rotBatchedEx functions apply the Givens rotation matrix defined by ``c=cos(alpha)`` and ``s=sin(alpha)`` to batched vectors ``x_i`` and`` y_i``, for ``i`` = 1, ..., ``batchCount``.
|
|
Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
|
|
If ``cs_type`` is real:
|
|
|
|
x := c * x + s * y
|
|
y := c * y - s * x
|
|
|
|
If ``cs_type`` is complex, the imaginary part of ``c`` is ignored:
|
|
|
|
x := real(c) * x + s * y
|
|
y := real(c) * y - conj(s) * x
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each x_i and y_i vectors.
|
|
@param[inout]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between elements of each x_i.
|
|
@param[inout]
|
|
y device array of device pointers storing each vector y_i.
|
|
@param[in]
|
|
yType
|
|
[hipDataType]
|
|
specifies the datatype of each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment between elements of each y_i.
|
|
@param[in]
|
|
c device pointer or host pointer to scalar cosine component of the rotation matrix.
|
|
@param[in]
|
|
s device pointer or host pointer to scalar sine component of the rotation matrix.
|
|
@param[in]
|
|
csType
|
|
[hipDataType]
|
|
specifies the datatype of c and s.
|
|
@param[in]
|
|
batchCount [int]
|
|
the number of x and y arrays, that is, the number of batches.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasRotBatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
const void* c,
|
|
const void* s,
|
|
hipDataType csType,
|
|
int batchCount,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasRotBatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
const void* c,
|
|
const void* s,
|
|
hipDataType csType,
|
|
int64_t batchCount,
|
|
hipDataType executionType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The rotStridedBatchedEx functions apply the Givens rotation matrix defined by ``c=cos(alpha)`` and ``s=sin(alpha)`` to strided batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., ``batchCount``.
|
|
Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is specified by calling ``hipblasSetPointerMode``.
|
|
|
|
If ``cs_type`` is real:
|
|
|
|
x := c * x + s * y
|
|
y := c * y - s * x
|
|
|
|
If ``cs_type`` is complex, the imaginary part of ``c`` is ignored:
|
|
|
|
x := real(c) * x + s * y
|
|
y := real(c) * y - conj(s) * x
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipblas library context queue.
|
|
@param[in]
|
|
n [int]
|
|
number of elements in each x_i and y_i vectors.
|
|
@param[inout]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment between elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
specifies the increment from the beginning of x_i to the beginning of x_(i+1).
|
|
@param[inout]
|
|
y device pointer to the first vector y_1.
|
|
@param[in]
|
|
yType
|
|
[hipDataType]
|
|
specifies the datatype of each vector y_i.
|
|
@param[in]
|
|
incy [int]
|
|
specifies the increment between elements of each y_i.
|
|
@param[in]
|
|
stridey [hipblasStride]
|
|
specifies the increment from the beginning of y_i to the beginning of y_(i+1).
|
|
@param[in]
|
|
c device pointer or host pointer to scalar cosine component of the rotation matrix.
|
|
@param[in]
|
|
s device pointer or host pointer to scalar sine component of the rotation matrix.
|
|
@param[in]
|
|
csType
|
|
[hipDataType]
|
|
specifies the datatype of c and s.
|
|
@param[in]
|
|
batchCount [int]
|
|
the number of x and y arrays, that is, the number of batches.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasRotStridedBatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
void* y,
|
|
hipDataType yType,
|
|
int incy,
|
|
hipblasStride stridey,
|
|
const void* c,
|
|
const void* s,
|
|
hipDataType csType,
|
|
int batchCount,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasRotStridedBatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
void* y,
|
|
hipDataType yType,
|
|
int64_t incy,
|
|
hipblasStride stridey,
|
|
const void* c,
|
|
const void* s,
|
|
hipDataType csType,
|
|
int64_t batchCount,
|
|
hipDataType executionType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The scalEx functions scale each element of vector ``x`` with scalar ``alpha``.
|
|
|
|
x := alpha * x
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x.
|
|
@param[in]
|
|
alpha device pointer or host pointer for the scalar alpha.
|
|
@param[in]
|
|
alphaType
|
|
[hipDataType]
|
|
specifies the datatype of alpha.
|
|
@param[inout]
|
|
x device pointer storing vector x.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of vector x.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of x.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScalEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScalEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
hipDataType executionType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The scalBatchedEx functions scale each element of each vector ``x_i`` with scalar ``alpha``:
|
|
|
|
x_i := alpha * x_i
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x.
|
|
@param[in]
|
|
alpha device pointer or host pointer for the scalar alpha.
|
|
@param[in]
|
|
alphaType
|
|
[hipDataType]
|
|
specifies the datatype of alpha.
|
|
@param[inout]
|
|
x device array of device pointers storing each vector x_i.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScalBatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
int batchCount,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScalBatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
int64_t batchCount,
|
|
hipDataType executionType);
|
|
|
|
/*! \brief <b> BLAS EX API </b>
|
|
|
|
\details
|
|
The scalStridedBatchedEx functions scale each element of vector ``x`` with scalar alpha over a set
|
|
of strided batched vectors.
|
|
|
|
x := alpha * x
|
|
|
|
The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation.
|
|
|
|
@param[in]
|
|
handle [hipblasHandle_t]
|
|
handle to the hipBLAS library context queue.
|
|
@param[in]
|
|
n [int]
|
|
the number of elements in x.
|
|
@param[in]
|
|
alpha device pointer or host pointer for the scalar alpha.
|
|
@param[in]
|
|
alphaType
|
|
[hipDataType]
|
|
specifies the datatype of alpha.
|
|
@param[inout]
|
|
x device pointer to the first vector x_1.
|
|
@param[in]
|
|
xType
|
|
[hipDataType]
|
|
specifies the datatype of each vector x_i.
|
|
@param[in]
|
|
incx [int]
|
|
specifies the increment for the elements of each x_i.
|
|
@param[in]
|
|
stridex [hipblasStride]
|
|
stride from the start of one vector (x_i) to the next one (x_i+1).
|
|
There are no restrictions placed on stridex. However, the user should
|
|
take care to ensure that stridex is of an appropriate size. For a typical
|
|
case, this means stridex >= n * incx.
|
|
@param[in]
|
|
batchCount [int]
|
|
number of instances in the batch.
|
|
@param[in]
|
|
executionType
|
|
[hipDataType]
|
|
specifies the datatype of computation.
|
|
|
|
********************************************************************/
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScalStridedBatchedEx(hipblasHandle_t handle,
|
|
int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
void* x,
|
|
hipDataType xType,
|
|
int incx,
|
|
hipblasStride stridex,
|
|
int batchCount,
|
|
hipDataType executionType);
|
|
|
|
// 64-bit interface
|
|
HIPBLAS_EXPORT hipblasStatus_t hipblasScalStridedBatchedEx_64(hipblasHandle_t handle,
|
|
int64_t n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
void* x,
|
|
hipDataType xType,
|
|
int64_t incx,
|
|
hipblasStride stridex,
|
|
int64_t batchCount,
|
|
hipDataType executionType);
|
|
|
|
/*! \brief <b> Auxiliary API </b>
|
|
|
|
\details
|
|
Returns a string representing the ``hipblasStatus_t`` value.
|
|
|
|
@param[in]
|
|
status [hipblasStatus_t]
|
|
hipBLAS status to convert to string.
|
|
*/
|
|
|
|
HIPBLAS_EXPORT const char* hipblasStatusToString(hipblasStatus_t status);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
// Macros used before hipBLAS version 3.0
|
|
#ifndef HIPBLAS_V2
|
|
#define HIPBLAS_V2
|
|
#endif
|
|
#define HIPBLAS_R_16F HIP_R_16F
|
|
#define HIPBLAS_R_32F HIP_R_32F
|
|
#define HIPBLAS_R_64F HIP_R_64F
|
|
#define HIPBLAS_C_16F HIP_C_16F
|
|
#define HIPBLAS_C_32F HIP_C_32F
|
|
#define HIPBLAS_C_64F HIP_C_64F
|
|
#define HIPBLAS_R_8I HIP_R_8I
|
|
#define HIPBLAS_R_8U HIP_R_8U
|
|
#define HIPBLAS_R_32I HIP_R_32I
|
|
#define HIPBLAS_R_32U HIP_R_32U
|
|
#define HIPBLAS_C_8I HIP_C_8I
|
|
#define HIPBLAS_C_8U HIP_C_8U
|
|
#define HIPBLAS_C_32I HIP_C_32I
|
|
#define HIPBLAS_C_32U HIP_C_32U
|
|
#define HIPBLAS_R_16B HIP_R_16BF
|
|
#define HIPBLAS_C_16B HIP_C_16BF
|
|
#define HIPBLAS_DATATYPE_INVALID hipDataType(31)
|