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
6919 lines
472 KiB
C
6919 lines
472 KiB
C
/* ************************************************************************
|
|
* Copyright (C) 2023-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 cop-
|
|
* ies 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 IM-
|
|
* PLIED, 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 CONNE-
|
|
* CTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* ************************************************************************ */
|
|
|
|
#if defined(HIPBLAS_INTERNAL_ILP64)
|
|
#define HIPBLAS_FAPI(_f) _f##_64Fortran
|
|
#define hipblas_int int64_t
|
|
#else
|
|
#define HIPBLAS_FAPI(_f) _f##Fortran
|
|
#define hipblas_int int
|
|
#endif
|
|
|
|
/* ==========
|
|
* L1
|
|
* ========== */
|
|
|
|
// amax
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIsamax)(
|
|
hipblasHandle_t handle, hipblas_int n, const float* x, hipblas_int incx, hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIdamax)(
|
|
hipblasHandle_t handle, hipblas_int n, const double* x, hipblas_int incx, hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIcamax)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIzamax)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblas_int* result);
|
|
|
|
// amaxBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIsamaxBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIdamaxBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIcamaxBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIzamaxBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
// amaxStridedBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIsamaxStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIdamaxStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIcamaxStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIzamaxStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
// amin
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIsamin)(
|
|
hipblasHandle_t handle, hipblas_int n, const float* x, hipblas_int incx, hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIdamin)(
|
|
hipblasHandle_t handle, hipblas_int n, const double* x, hipblas_int incx, hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIcamin)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIzamin)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblas_int* result);
|
|
|
|
// aminBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIsaminBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIdaminBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIcaminBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIzaminBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
// aminStridedBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIsaminStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIdaminStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIcaminStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasIzaminStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
hipblas_int* result);
|
|
|
|
// asum
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSasum)(
|
|
hipblasHandle_t handle, hipblas_int n, const float* x, hipblas_int incx, float* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDasum)(
|
|
hipblasHandle_t handle, hipblas_int n, const double* x, hipblas_int incx, double* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScasum)(
|
|
hipblasHandle_t handle, hipblas_int n, const hipComplex* x, hipblas_int incx, float* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDzasum)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
double* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSasumBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
float* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDasumBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
double* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScasumBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
float* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDzasumBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
double* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSasumStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
float* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDasumStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
double* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScasumStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
float* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDzasumStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
double* results);
|
|
|
|
// axpy
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasHaxpy)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* x,
|
|
hipblas_int incx,
|
|
hipblasHalf* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSaxpy)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
float* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDaxpy)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
double* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCaxpy)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZaxpy)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasHaxpyBatched)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* const x[],
|
|
hipblas_int incx,
|
|
hipblasHalf* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSaxpyBatched)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
float* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDaxpyBatched)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
double* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCaxpyBatched)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZaxpyBatched)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasHaxpyStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* x,
|
|
hipblas_int incx,
|
|
const hipblasStride stride_x,
|
|
hipblasHalf* y,
|
|
hipblas_int incy,
|
|
const hipblasStride stride_y,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSaxpyStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
const hipblasStride stride_x,
|
|
float* y,
|
|
hipblas_int incy,
|
|
const hipblasStride stride_y,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDaxpyStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
const hipblasStride stride_x,
|
|
double* y,
|
|
hipblas_int incy,
|
|
const hipblasStride stride_y,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCaxpyStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipblasStride stride_x,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
const hipblasStride stride_y,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZaxpyStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int N,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipblasStride stride_x,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
const hipblasStride stride_y,
|
|
hipblas_int batch_count);
|
|
|
|
// copy
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScopy)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
float* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDcopy)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
double* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCcopy)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZcopy)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScopyBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
float* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDcopyBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
double* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCcopyBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZcopyBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScopyStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDcopyStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCcopyStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZcopyStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
// dot
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSdot)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
const float* y,
|
|
hipblas_int incy,
|
|
float* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDdot)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
const double* y,
|
|
hipblas_int incy,
|
|
double* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasHdot)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipblasHalf* x,
|
|
hipblas_int incx,
|
|
const hipblasHalf* y,
|
|
hipblas_int incy,
|
|
hipblasHalf* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasBfdot)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipblasBfloat16* x,
|
|
hipblas_int incx,
|
|
const hipblasBfloat16* y,
|
|
hipblas_int incy,
|
|
hipblasBfloat16* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCdotu)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipComplex* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdotu)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipDoubleComplex* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCdotc)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipComplex* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdotc)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipDoubleComplex* result);
|
|
|
|
// dotBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSdotBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
const float* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count,
|
|
float* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDdotBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
const double* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count,
|
|
double* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasHdotBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipblasHalf* const x[],
|
|
hipblas_int incx,
|
|
const hipblasHalf* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count,
|
|
hipblasHalf* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasBfdotBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipblasBfloat16* const x[],
|
|
hipblas_int incx,
|
|
const hipblasBfloat16* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count,
|
|
hipblasBfloat16* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCdotuBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count,
|
|
hipComplex* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdotuBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count,
|
|
hipDoubleComplex* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCdotcBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count,
|
|
hipComplex* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdotcBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count,
|
|
hipDoubleComplex* result);
|
|
|
|
// dotStridedBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSdotStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count,
|
|
float* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDdotStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count,
|
|
double* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasHdotStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipblasHalf* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipblasHalf* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count,
|
|
hipblasHalf* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasBfdotStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipblasBfloat16* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipblasBfloat16* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count,
|
|
hipblasBfloat16* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCdotuStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count,
|
|
hipComplex* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdotuStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count,
|
|
hipDoubleComplex* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCdotcStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count,
|
|
hipComplex* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdotcStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count,
|
|
hipDoubleComplex* result);
|
|
|
|
// nrm2
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSnrm2)(
|
|
hipblasHandle_t handle, hipblas_int n, const float* x, hipblas_int incx, float* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDnrm2)(
|
|
hipblasHandle_t handle, hipblas_int n, const double* x, hipblas_int incx, double* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScnrm2)(
|
|
hipblasHandle_t handle, hipblas_int n, const hipComplex* x, hipblas_int incx, float* result);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDznrm2)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
double* result);
|
|
|
|
// nrm2Batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSnrm2Batched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
float* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDnrm2Batched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
double* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScnrm2Batched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
float* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDznrm2Batched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
double* results);
|
|
|
|
// nrm2StridedBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSnrm2StridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
float* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDnrm2StridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
double* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScnrm2StridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
float* results);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDznrm2StridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
double* results);
|
|
|
|
// rot
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSrot)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
float* x,
|
|
hipblas_int incx,
|
|
float* y,
|
|
hipblas_int incy,
|
|
const float* c,
|
|
const float* s);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDrot)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
double* x,
|
|
hipblas_int incx,
|
|
double* y,
|
|
hipblas_int incy,
|
|
const double* c,
|
|
const double* s);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCrot)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
const float* c,
|
|
const hipComplex* s);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsrot)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
const float* c,
|
|
const float* s);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZrot)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
const double* c,
|
|
const hipDoubleComplex* s);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdrot)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
const double* c,
|
|
const double* s);
|
|
|
|
// rotBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSrotBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
float* const x[],
|
|
hipblas_int incx,
|
|
float* const y[],
|
|
hipblas_int incy,
|
|
const float* c,
|
|
const float* s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDrotBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
double* const x[],
|
|
hipblas_int incx,
|
|
double* const y[],
|
|
hipblas_int incy,
|
|
const double* c,
|
|
const double* s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCrotBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
const float* c,
|
|
const hipComplex* s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsrotBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
const float* c,
|
|
const float* s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZrotBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
const double* c,
|
|
const hipDoubleComplex* s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdrotBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
const double* c,
|
|
const double* s,
|
|
hipblas_int batch_count);
|
|
|
|
// rotStridedBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSrotStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
const float* c,
|
|
const float* s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDrotStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
const double* c,
|
|
const double* s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCrotStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
const float* c,
|
|
const hipComplex* s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsrotStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
const float* c,
|
|
const float* s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZrotStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
const double* c,
|
|
const hipDoubleComplex* s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdrotStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
const double* c,
|
|
const double* s,
|
|
hipblas_int batch_count);
|
|
|
|
// rotg
|
|
hipblasStatus_t
|
|
HIPBLAS_FAPI(hipblasSrotg)(hipblasHandle_t handle, float* a, float* b, float* c, float* s);
|
|
|
|
hipblasStatus_t
|
|
HIPBLAS_FAPI(hipblasDrotg)(hipblasHandle_t handle, double* a, double* b, double* c, double* s);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCrotg)(
|
|
hipblasHandle_t handle, hipComplex* a, hipComplex* b, float* c, hipComplex* s);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZrotg)(hipblasHandle_t handle,
|
|
hipDoubleComplex* a,
|
|
hipDoubleComplex* b,
|
|
double* c,
|
|
hipDoubleComplex* s);
|
|
|
|
// rotgBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSrotgBatched)(hipblasHandle_t handle,
|
|
float* const a[],
|
|
float* const b[],
|
|
float* const c[],
|
|
float* const s[],
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDrotgBatched)(hipblasHandle_t handle,
|
|
double* const a[],
|
|
double* const b[],
|
|
double* const c[],
|
|
double* const s[],
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCrotgBatched)(hipblasHandle_t handle,
|
|
hipComplex* const a[],
|
|
hipComplex* const b[],
|
|
float* const c[],
|
|
hipComplex* const s[],
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZrotgBatched)(hipblasHandle_t handle,
|
|
hipDoubleComplex* const a[],
|
|
hipDoubleComplex* const b[],
|
|
double* const c[],
|
|
hipDoubleComplex* const s[],
|
|
hipblas_int batch_count);
|
|
|
|
// rotgStridedBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSrotgStridedBatched)(hipblasHandle_t handle,
|
|
float* a,
|
|
hipblasStride stride_a,
|
|
float* b,
|
|
hipblasStride stride_b,
|
|
float* c,
|
|
hipblasStride stride_c,
|
|
float* s,
|
|
hipblasStride stride_s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDrotgStridedBatched)(hipblasHandle_t handle,
|
|
double* a,
|
|
hipblasStride stride_a,
|
|
double* b,
|
|
hipblasStride stride_b,
|
|
double* c,
|
|
hipblasStride stride_c,
|
|
double* s,
|
|
hipblasStride stride_s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCrotgStridedBatched)(hipblasHandle_t handle,
|
|
hipComplex* a,
|
|
hipblasStride stride_a,
|
|
hipComplex* b,
|
|
hipblasStride stride_b,
|
|
float* c,
|
|
hipblasStride stride_c,
|
|
hipComplex* s,
|
|
hipblasStride stride_s,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZrotgStridedBatched)(hipblasHandle_t handle,
|
|
hipDoubleComplex* a,
|
|
hipblasStride stride_a,
|
|
hipDoubleComplex* b,
|
|
hipblasStride stride_b,
|
|
double* c,
|
|
hipblasStride stride_c,
|
|
hipDoubleComplex* s,
|
|
hipblasStride stride_s,
|
|
hipblas_int batch_count);
|
|
|
|
// rotm
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSrotm)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
float* x,
|
|
hipblas_int incx,
|
|
float* y,
|
|
hipblas_int incy,
|
|
const float* param);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDrotm)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
double* x,
|
|
hipblas_int incx,
|
|
double* y,
|
|
hipblas_int incy,
|
|
const double* param);
|
|
|
|
// rotmBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSrotmBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
float* const x[],
|
|
hipblas_int incx,
|
|
float* const y[],
|
|
hipblas_int incy,
|
|
const float* const param[],
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDrotmBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
double* const x[],
|
|
hipblas_int incx,
|
|
double* const y[],
|
|
hipblas_int incy,
|
|
const double* const param[],
|
|
hipblas_int batch_count);
|
|
|
|
// rotmStridedBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSrotmStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
const float* param,
|
|
hipblasStride stride_param,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDrotmStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
const double* param,
|
|
hipblasStride stride_param,
|
|
hipblas_int batch_count);
|
|
|
|
// rotmg
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSrotmg)(
|
|
hipblasHandle_t handle, float* d1, float* d2, float* x1, const float* y1, float* param);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDrotmg)(
|
|
hipblasHandle_t handle, double* d1, double* d2, double* x1, const double* y1, double* param);
|
|
|
|
// rotmgBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSrotmgBatched)(hipblasHandle_t handle,
|
|
float* const d1[],
|
|
float* const d2[],
|
|
float* const x1[],
|
|
const float* const y1[],
|
|
float* const param[],
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDrotmgBatched)(hipblasHandle_t handle,
|
|
double* const d1[],
|
|
double* const d2[],
|
|
double* const x1[],
|
|
const double* const y1[],
|
|
double* const param[],
|
|
hipblas_int batch_count);
|
|
|
|
// rotmgStridedBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSrotmgStridedBatched)(hipblasHandle_t handle,
|
|
float* d1,
|
|
hipblasStride stride_d1,
|
|
float* d2,
|
|
hipblasStride stride_d2,
|
|
float* x1,
|
|
hipblasStride stride_x1,
|
|
const float* y1,
|
|
hipblasStride stride_y1,
|
|
float* param,
|
|
hipblasStride stride_param,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDrotmgStridedBatched)(hipblasHandle_t handle,
|
|
double* d1,
|
|
hipblasStride stride_d1,
|
|
double* d2,
|
|
hipblasStride stride_d2,
|
|
double* x1,
|
|
hipblasStride stride_x1,
|
|
const double* y1,
|
|
hipblasStride stride_y1,
|
|
double* param,
|
|
hipblasStride stride_param,
|
|
hipblas_int batch_count);
|
|
|
|
// scal
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSscal)(
|
|
hipblasHandle_t handle, hipblas_int n, const float* alpha, float* x, hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDscal)(
|
|
hipblasHandle_t handle, hipblas_int n, const double* alpha, double* x, hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCscal)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
hipComplex* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZscal)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsscal)(
|
|
hipblasHandle_t handle, hipblas_int n, const float* alpha, hipComplex* x, hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdscal)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx);
|
|
|
|
// scalBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSscalBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
float* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDscalBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
double* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCscalBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZscalBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsscalBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdscalBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
// scalStridedBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSscalStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDscalStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCscalStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZscalStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsscalStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdscalStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
// swap
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSswap)(
|
|
hipblasHandle_t handle, hipblas_int n, float* x, hipblas_int incx, float* y, hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDswap)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
double* x,
|
|
hipblas_int incx,
|
|
double* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCswap)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZswap)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy);
|
|
|
|
// swapBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSswapBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
float* const x[],
|
|
hipblas_int incx,
|
|
float* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDswapBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
double* const x[],
|
|
hipblas_int incx,
|
|
double* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCswapBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZswapBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
// swapStridedBatched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSswapStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDswapStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCswapStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZswapStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
/* ==========
|
|
* L2
|
|
* ========== */
|
|
|
|
// ger
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSger)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
const float* y,
|
|
hipblas_int incy,
|
|
float* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDger)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
const double* y,
|
|
hipblas_int incy,
|
|
double* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgeru)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipComplex* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgerc)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipComplex* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgeru)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgerc)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda);
|
|
|
|
// ger_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgerBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
const float* const y[],
|
|
hipblas_int incy,
|
|
float* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgerBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
const double* const y[],
|
|
hipblas_int incy,
|
|
double* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgeruBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgercBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgeruBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgercBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batch_count);
|
|
|
|
// ger_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgerStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgerStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgeruStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgercStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgeruStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgercStridedBatched)(hipblasHandle_t handle,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batch_count);
|
|
|
|
// gbmv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgbmv)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
const float* beta,
|
|
float* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgbmv)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
const double* beta,
|
|
double* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgbmv)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgbmv)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy);
|
|
|
|
// gbmv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgbmvBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgbmvBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgbmvBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgbmvBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
// gbmv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
const float* beta,
|
|
float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
const double* beta,
|
|
double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int kl,
|
|
hipblas_int ku,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
hipblas_int batch_count);
|
|
|
|
// gemv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgemv)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
const float* beta,
|
|
float* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgemv)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
const double* beta,
|
|
double* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgemv)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgemv)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy);
|
|
|
|
// gemv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgemvBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgemvBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgemvBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgemvBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
// gemv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgemvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgemvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgemvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgemvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count);
|
|
|
|
// her
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCher)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipComplex* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZher)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda);
|
|
|
|
// her_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCherBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZherBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batchCount);
|
|
|
|
// her_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCherStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZherStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batchCount);
|
|
|
|
// her2
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCher2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipComplex* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZher2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda);
|
|
|
|
// her2_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCher2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZher2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batchCount);
|
|
|
|
// her2_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCher2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZher2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batchCount);
|
|
// hpmv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy);
|
|
|
|
// hpmv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
// hpmv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
hipblasStride strideAP,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
hipblasStride strideAP,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
// hpr
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipComplex* AP);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipDoubleComplex* AP);
|
|
|
|
// hpr_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChprBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipComplex* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhprBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipDoubleComplex* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
// hpr_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChprStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhprStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
// hpr2
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpr2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipComplex* AP);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpr2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipDoubleComplex* AP);
|
|
|
|
// hpr2_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpr2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipComplex* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpr2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipDoubleComplex* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
// hpr2_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpr2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpr2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
// spr
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSspr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
float* AP);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDspr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
double* AP);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCspr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipComplex* AP);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZspr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipDoubleComplex* AP);
|
|
|
|
// spr_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsprBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
float* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsprBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
double* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsprBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipComplex* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsprBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipDoubleComplex* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
// spr_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsprStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
float* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsprStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
double* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsprStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsprStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
// spr2
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSspr2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
const float* y,
|
|
hipblas_int incy,
|
|
float* AP);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDspr2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
const double* y,
|
|
hipblas_int incy,
|
|
double* AP);
|
|
|
|
// spr2_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSspr2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
const float* const y[],
|
|
hipblas_int incy,
|
|
float* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDspr2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
const double* const y[],
|
|
hipblas_int incy,
|
|
double* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
// spr2_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSspr2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
float* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDspr2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
double* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
// symv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsymv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
const float* beta,
|
|
float* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsymv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
const double* beta,
|
|
double* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsymv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsymv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy);
|
|
|
|
// symv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsymvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsymvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsymvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsymvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
// symv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsymvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsymvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsymvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsymvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
// syr
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
float* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
double* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipComplex* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda);
|
|
|
|
// syr_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyrBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
float* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyrBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
double* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyrBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyrBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batch_count);
|
|
|
|
// syr_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyrStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyrStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyrStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyrStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batch_count);
|
|
|
|
// syr2
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyr2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
const float* y,
|
|
hipblas_int incy,
|
|
float* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyr2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
const double* y,
|
|
hipblas_int incy,
|
|
double* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyr2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipComplex* A,
|
|
hipblas_int lda);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyr2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda);
|
|
|
|
// syr2_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyr2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
const float* const y[],
|
|
hipblas_int incy,
|
|
float* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyr2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
const double* const y[],
|
|
hipblas_int incy,
|
|
double* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyr2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyr2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
hipblas_int batchCount);
|
|
|
|
// syr2_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyr2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyr2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyr2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyr2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipblas_int batchCount);
|
|
|
|
// hbmv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChbmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhbmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy);
|
|
|
|
// hbmv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChbmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhbmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
// hbmv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
// hemv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChemv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhemv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy);
|
|
|
|
// hemv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChemvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhemvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batch_count);
|
|
|
|
// hemv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChemvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhemvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stride_y,
|
|
hipblas_int batch_count);
|
|
|
|
// hpmv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy);
|
|
|
|
// hpmv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const AP[],
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* beta,
|
|
hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const AP[],
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
// hpmv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* AP,
|
|
hipblasStride strideAP,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* beta,
|
|
hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* AP,
|
|
hipblasStride strideAP,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
// hpr
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipComplex* AP);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpr)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipDoubleComplex* AP);
|
|
|
|
// hpr_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChprBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipComplex* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhprBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipDoubleComplex* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
// hpr_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChprStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhprStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipDoubleComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
// hpr2
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpr2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipComplex* AP);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpr2)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipDoubleComplex* AP);
|
|
|
|
// hpr2_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpr2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipComplex* const y[],
|
|
hipblas_int incy,
|
|
hipComplex* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpr2Batched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
const hipDoubleComplex* const y[],
|
|
hipblas_int incy,
|
|
hipDoubleComplex* const AP[],
|
|
hipblas_int batchCount);
|
|
|
|
// hpr2_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChpr2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhpr2StridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const hipDoubleComplex* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipDoubleComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipblas_int batchCount);
|
|
|
|
// sbmv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsbmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
const float* beta,
|
|
float* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsbmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
const double* beta,
|
|
double* y,
|
|
hipblas_int incy);
|
|
|
|
// sbmv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsbmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsbmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
// sbmv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
// spmv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSspmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
const float* beta,
|
|
float* y,
|
|
hipblas_int incy);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDspmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
const double* beta,
|
|
double* y,
|
|
hipblas_int incy);
|
|
|
|
// spmv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSspmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const AP[],
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
const float* beta,
|
|
float* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDspmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const AP[],
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
const double* beta,
|
|
double* const y[],
|
|
hipblas_int incy,
|
|
hipblas_int batchCount);
|
|
|
|
// spmv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSspmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* AP,
|
|
hipblasStride strideAP,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const float* beta,
|
|
float* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDspmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* AP,
|
|
hipblasStride strideAP,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const double* beta,
|
|
double* y,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batchCount);
|
|
|
|
// tbmv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStbmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
float* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtbmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
double* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtbmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipComplex* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtbmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx);
|
|
|
|
// tbmv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStbmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
float* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtbmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
double* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtbmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtbmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
// tbmv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtbmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
// tpmv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStpmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* AP,
|
|
float* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtpmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* AP,
|
|
double* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtpmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* AP,
|
|
hipComplex* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtpmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* AP,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx);
|
|
|
|
// tpmv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStpmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* const AP[],
|
|
float* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtpmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* const AP[],
|
|
double* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtpmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* const AP[],
|
|
hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtpmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* const AP[],
|
|
hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
// tpmv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStpmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* AP,
|
|
hipblasStride strideAP,
|
|
float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtpmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* AP,
|
|
hipblasStride strideAP,
|
|
double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtpmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtpmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
// trmv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
float* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
double* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipComplex* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrmv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx);
|
|
|
|
// trmv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
float* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
double* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrmvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
// trmv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrmvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_a,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipblas_int batch_count);
|
|
|
|
// tbsv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStbsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
float* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtbsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
double* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtbsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipComplex* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtbsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx);
|
|
|
|
// tbsv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStbsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
float* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtbsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
double* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtbsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtbsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
// tbsv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStbsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtbsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtbsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtbsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
// tpsv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStpsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* AP,
|
|
float* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtpsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* AP,
|
|
double* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtpsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* AP,
|
|
hipComplex* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtpsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* AP,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx);
|
|
|
|
// tpsv_bathced
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStpsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* const AP[],
|
|
float* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtpsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* const AP[],
|
|
double* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtpsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* const AP[],
|
|
hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtpsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* const AP[],
|
|
hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batchCount);
|
|
|
|
// tpsv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStpsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* AP,
|
|
hipblasStride strideAP,
|
|
float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtpsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* AP,
|
|
hipblasStride strideAP,
|
|
double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtpsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtpsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* AP,
|
|
hipblasStride strideAP,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batchCount);
|
|
|
|
// trsv
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
float* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
double* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipComplex* x,
|
|
hipblas_int incx);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrsv)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx);
|
|
|
|
// trsv_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
float* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
double* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrsvBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipblas_int batch_count);
|
|
|
|
// trsv_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrsvStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count);
|
|
|
|
/* ==========
|
|
* L3
|
|
* ========== */
|
|
|
|
// herk
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCherk)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const float* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZherk)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const double* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// herk_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCherkBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const float* beta,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZherkBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const double* beta,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
// herk_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCherkStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const float* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZherkStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const double* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
// herkx
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCherkx)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZherkx)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// herkx_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCherkxBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const B[],
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZherkxBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const B[],
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
// herkx_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCherkxStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZherkxStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
// her2k
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCher2k)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZher2k)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// her2k_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCher2kBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const B[],
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZher2kBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const B[],
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
// her2k_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCher2kStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZher2kStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
// symm
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsymm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
float* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsymm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
double* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsymm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsymm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// symm_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsymmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* const B[],
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
float* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsymmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* const B[],
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
double* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsymmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const B[],
|
|
hipblas_int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsymmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const B[],
|
|
hipblas_int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
// symm_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsymmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
float* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsymmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
double* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsymmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsymmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
// syrk
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyrk)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* beta,
|
|
float* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyrk)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* beta,
|
|
double* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyrk)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyrk)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// syrk_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyrkBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* beta,
|
|
float* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyrkBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* beta,
|
|
double* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyrkBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* beta,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyrkBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
// syrk_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyrkStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const float* beta,
|
|
float* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyrkStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const double* beta,
|
|
double* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyrkStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyrkStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
// syr2k
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyr2k)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
float* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyr2k)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
double* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyr2k)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyr2k)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// syr2k_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyr2kBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* const B[],
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
float* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyr2kBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* const B[],
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
double* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyr2kBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const B[],
|
|
hipblas_int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyr2kBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const B[],
|
|
hipblas_int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
// syr2k_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyr2kStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
float* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyr2kStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
double* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyr2kStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyr2kStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
// syrkx
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyrkx)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
float* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyrkx)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
double* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyrkx)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyrkx)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// syrkx_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyrkxBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* const B[],
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
float* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyrkxBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* const B[],
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
double* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyrkxBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const B[],
|
|
hipblas_int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyrkxBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const B[],
|
|
hipblas_int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
// syrkx_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSsyrkxStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const float* beta,
|
|
float* C,
|
|
hipblas_int ldc,
|
|
hipblasStride stridec,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDsyrkxStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const double* beta,
|
|
double* C,
|
|
hipblas_int ldc,
|
|
hipblasStride stridec,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCsyrkxStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride stridec,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZsyrkxStridedBatched)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride stridec,
|
|
hipblas_int batchCount);
|
|
|
|
// geam
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgeam)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* beta,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
float* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgeam)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* beta,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
double* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgeam)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* beta,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgeam)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* beta,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// geam_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgeamBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* beta,
|
|
const float* const B[],
|
|
hipblas_int ldb,
|
|
float* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgeamBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* beta,
|
|
const double* const B[],
|
|
hipblas_int ldb,
|
|
double* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgeamBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* beta,
|
|
const hipComplex* const B[],
|
|
hipblas_int ldb,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgeamBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* beta,
|
|
const hipDoubleComplex* const B[],
|
|
hipblas_int ldb,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
// geam_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgeamStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const float* beta,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
float* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgeamStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const double* beta,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
double* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgeamStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* beta,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgeamStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* beta,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
// hemm
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChemm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhemm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// hemm_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChemmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const B[],
|
|
hipblas_int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhemmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const B[],
|
|
hipblas_int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
// hemm_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasChemmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZhemmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
// trmm
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrmm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
float* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrmm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
double* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrmm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrmm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// trmm_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrmmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* const B[],
|
|
hipblas_int ldb,
|
|
float* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrmmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* const B[],
|
|
hipblas_int ldb,
|
|
double* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrmmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const B[],
|
|
hipblas_int ldb,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrmmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const B[],
|
|
hipblas_int ldb,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
// trmm_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrmmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
float* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrmmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
double* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrmmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrmmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount);
|
|
|
|
// dgmm
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSdgmm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
float* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDdgmm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
double* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCdgmm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdgmm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// dgmm_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSdgmmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* const x[],
|
|
hipblas_int incx,
|
|
float* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDdgmmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* const x[],
|
|
hipblas_int incx,
|
|
double* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCdgmmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const x[],
|
|
hipblas_int incx,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdgmmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const x[],
|
|
hipblas_int incx,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batch_count);
|
|
|
|
// dgmm_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSdgmmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_A,
|
|
const float* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
float* C,
|
|
hipblas_int ldc,
|
|
hipblasStride stride_C,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDdgmmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_A,
|
|
const double* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
double* C,
|
|
hipblas_int ldc,
|
|
hipblasStride stride_C,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCdgmmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_A,
|
|
const hipComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride stride_C,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZdgmmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride stride_A,
|
|
const hipDoubleComplex* x,
|
|
hipblas_int incx,
|
|
hipblasStride stride_x,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
hipblasStride stride_C,
|
|
hipblas_int batch_count);
|
|
|
|
// trsm
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrsm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
float* B,
|
|
hipblas_int ldb);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrsm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
double* B,
|
|
hipblas_int ldb);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrsm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipComplex* B,
|
|
hipblas_int ldb);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrsm)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipDoubleComplex* B,
|
|
hipblas_int ldb);
|
|
|
|
// trsm_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrsmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
float* const B[],
|
|
hipblas_int ldb,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrsmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
double* const B[],
|
|
hipblas_int ldb,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrsmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
hipComplex* const B[],
|
|
hipblas_int ldb,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrsmBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
hipDoubleComplex* const B[],
|
|
hipblas_int ldb,
|
|
hipblas_int batch_count);
|
|
|
|
// trsm_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasStrsmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
float* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDtrsmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
double* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCtrsmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
hipblas_int batch_count);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZtrsmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasSideMode_t side,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t transA,
|
|
hipblasDiagType_t diag,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
hipblas_int batch_count);
|
|
|
|
// gemm
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasHgemm)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* A,
|
|
hipblas_int lda,
|
|
const hipblasHalf* B,
|
|
hipblas_int ldb,
|
|
const hipblasHalf* beta,
|
|
hipblasHalf* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgemm)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
float* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgemm)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
double* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgemm)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgemm)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc);
|
|
|
|
// gemm batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasHgemmBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* const A[],
|
|
hipblas_int lda,
|
|
const hipblasHalf* const B[],
|
|
hipblas_int ldb,
|
|
const hipblasHalf* beta,
|
|
hipblasHalf* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgemmBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* const A[],
|
|
hipblas_int lda,
|
|
const float* const B[],
|
|
hipblas_int ldb,
|
|
const float* beta,
|
|
float* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgemmBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* const A[],
|
|
hipblas_int lda,
|
|
const double* const B[],
|
|
hipblas_int ldb,
|
|
const double* beta,
|
|
double* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgemmBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipComplex* const B[],
|
|
hipblas_int ldb,
|
|
const hipComplex* beta,
|
|
hipComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgemmBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* const A[],
|
|
hipblas_int lda,
|
|
const hipDoubleComplex* const B[],
|
|
hipblas_int ldb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* const C[],
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount);
|
|
|
|
// gemm_strided_batched
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasHgemmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipblasHalf* alpha,
|
|
const hipblasHalf* A,
|
|
hipblas_int lda,
|
|
long long bsa,
|
|
const hipblasHalf* B,
|
|
hipblas_int ldb,
|
|
long long bsb,
|
|
const hipblasHalf* beta,
|
|
hipblasHalf* C,
|
|
hipblas_int ldc,
|
|
long long bsc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSgemmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const float* alpha,
|
|
const float* A,
|
|
hipblas_int lda,
|
|
long long bsa,
|
|
const float* B,
|
|
hipblas_int ldb,
|
|
long long bsb,
|
|
const float* beta,
|
|
float* C,
|
|
hipblas_int ldc,
|
|
long long bsc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDgemmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const double* alpha,
|
|
const double* A,
|
|
hipblas_int lda,
|
|
long long bsa,
|
|
const double* B,
|
|
hipblas_int ldb,
|
|
long long bsb,
|
|
const double* beta,
|
|
double* C,
|
|
hipblas_int ldc,
|
|
long long bsc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasCgemmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipComplex* alpha,
|
|
const hipComplex* A,
|
|
hipblas_int lda,
|
|
long long bsa,
|
|
const hipComplex* B,
|
|
hipblas_int ldb,
|
|
long long bsb,
|
|
const hipComplex* beta,
|
|
hipComplex* C,
|
|
hipblas_int ldc,
|
|
long long bsc,
|
|
hipblas_int batchCount);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasZgemmStridedBatched)(hipblasHandle_t handle,
|
|
hipblasOperation_t transa,
|
|
hipblasOperation_t transb,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const hipDoubleComplex* alpha,
|
|
const hipDoubleComplex* A,
|
|
hipblas_int lda,
|
|
long long bsa,
|
|
const hipDoubleComplex* B,
|
|
hipblas_int ldb,
|
|
long long bsb,
|
|
const hipDoubleComplex* beta,
|
|
hipDoubleComplex* C,
|
|
hipblas_int ldc,
|
|
long long bsc,
|
|
hipblas_int batchCount);
|
|
|
|
/* ==========
|
|
* _Ex
|
|
* ========== */
|
|
|
|
// axpy_ex
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasAxpyEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasAxpyBatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
hipblas_int batch_count,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasAxpyStridedBatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count,
|
|
hipDataType executionType);
|
|
|
|
// dot_ex
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDotEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDotcEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDotBatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
hipblas_int batch_count,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDotcBatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
const void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
hipblas_int batch_count,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDotStridedBatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasDotcStridedBatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
const void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
hipblas_int batch_count,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
// nrm2_ex
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasNrm2Ex)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasNrm2BatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasNrm2StridedBatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
void* result,
|
|
hipDataType resultType,
|
|
hipDataType executionType);
|
|
|
|
// rot_ex
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasRotEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
const void* c,
|
|
const void* s,
|
|
hipDataType csType,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasRotBatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
const void* c,
|
|
const void* s,
|
|
hipDataType csType,
|
|
hipblas_int batch_count,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasRotStridedBatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
void* y,
|
|
hipDataType yType,
|
|
hipblas_int incy,
|
|
hipblasStride stridey,
|
|
const void* c,
|
|
const void* s,
|
|
hipDataType csType,
|
|
hipblas_int batch_count,
|
|
hipDataType executionType);
|
|
|
|
// scal_ex
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScalEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScalBatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
hipblas_int batch_count,
|
|
hipDataType executionType);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasScalStridedBatchedEx)(hipblasHandle_t handle,
|
|
hipblas_int n,
|
|
const void* alpha,
|
|
hipDataType alphaType,
|
|
void* x,
|
|
hipDataType xType,
|
|
hipblas_int incx,
|
|
hipblasStride stridex,
|
|
hipblas_int batch_count,
|
|
hipDataType executionType);
|
|
|
|
// gemmex
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasGemmEx)(hipblasHandle_t handle,
|
|
hipblasOperation_t trans_a,
|
|
hipblasOperation_t trans_b,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const void* alpha,
|
|
const void* a,
|
|
hipDataType a_type,
|
|
hipblas_int lda,
|
|
const void* b,
|
|
hipDataType b_type,
|
|
hipblas_int ldb,
|
|
const void* beta,
|
|
void* c,
|
|
hipDataType c_type,
|
|
hipblas_int ldc,
|
|
hipblasComputeType_t compute_type,
|
|
hipblasGemmAlgo_t algo);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasGemmBatchedEx)(hipblasHandle_t handle,
|
|
hipblasOperation_t trans_a,
|
|
hipblasOperation_t trans_b,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const void* alpha,
|
|
const void* a[],
|
|
hipDataType a_type,
|
|
hipblas_int lda,
|
|
const void* b[],
|
|
hipDataType b_type,
|
|
hipblas_int ldb,
|
|
const void* beta,
|
|
void* c[],
|
|
hipDataType c_type,
|
|
hipblas_int ldc,
|
|
hipblas_int batch_count,
|
|
hipblasComputeType_t compute_type,
|
|
hipblasGemmAlgo_t algo);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasGemmStridedBatchedEx)(hipblasHandle_t handle,
|
|
hipblasOperation_t trans_a,
|
|
hipblasOperation_t trans_b,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const void* alpha,
|
|
const void* a,
|
|
hipDataType a_type,
|
|
hipblas_int lda,
|
|
hipblasStride stride_A,
|
|
const void* b,
|
|
hipDataType b_type,
|
|
hipblas_int ldb,
|
|
hipblasStride stride_B,
|
|
const void* beta,
|
|
void* c,
|
|
hipDataType c_type,
|
|
hipblas_int ldc,
|
|
hipblasStride stride_C,
|
|
hipblas_int batch_count,
|
|
hipblasComputeType_t compute_type,
|
|
hipblasGemmAlgo_t algo);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasGemmExWithFlags)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
hipblas_int lda,
|
|
const void* B,
|
|
hipDataType bType,
|
|
hipblas_int ldb,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
hipblas_int ldc,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo,
|
|
hipblasGemmFlags_t flags);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasGemmBatchedExWithFlags)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const void* alpha,
|
|
const void* A[],
|
|
hipDataType aType,
|
|
hipblas_int lda,
|
|
const void* B[],
|
|
hipDataType bType,
|
|
hipblas_int ldb,
|
|
const void* beta,
|
|
void* C[],
|
|
hipDataType cType,
|
|
hipblas_int ldc,
|
|
hipblas_int batchCount,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo,
|
|
hipblasGemmFlags_t flags);
|
|
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasGemmStridedBatchedExWithFlags)(hipblasHandle_t handle,
|
|
hipblasOperation_t transA,
|
|
hipblasOperation_t transB,
|
|
hipblas_int m,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const void* alpha,
|
|
const void* A,
|
|
hipDataType aType,
|
|
hipblas_int lda,
|
|
hipblasStride strideA,
|
|
const void* B,
|
|
hipDataType bType,
|
|
hipblas_int ldb,
|
|
hipblasStride strideB,
|
|
const void* beta,
|
|
void* C,
|
|
hipDataType cType,
|
|
hipblas_int ldc,
|
|
hipblasStride strideC,
|
|
hipblas_int batchCount,
|
|
hipblasComputeType_t computeType,
|
|
hipblasGemmAlgo_t algo,
|
|
hipblasGemmFlags_t flags);
|
|
|
|
// syrkex
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasSyrkEx)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t trans_a,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const void* alpha,
|
|
const void* a,
|
|
hipDataType a_type,
|
|
hipblas_int lda,
|
|
const void* beta,
|
|
void* c,
|
|
hipDataType c_type,
|
|
hipblas_int ldc,
|
|
hipDataType compute_type);
|
|
|
|
// herkex
|
|
hipblasStatus_t HIPBLAS_FAPI(hipblasHerkEx)(hipblasHandle_t handle,
|
|
hipblasFillMode_t uplo,
|
|
hipblasOperation_t trans_a,
|
|
hipblas_int n,
|
|
hipblas_int k,
|
|
const void* alpha,
|
|
const void* a,
|
|
hipDataType a_type,
|
|
hipblas_int lda,
|
|
const void* beta,
|
|
void* c,
|
|
hipDataType c_type,
|
|
hipblas_int ldc,
|
|
hipDataType compute_type);
|
|
|
|
#undef HIPBLAS_FAPI
|
|
#undef hipblas_int
|