/* ************************************************************************
* Copyright (C) 2016-2025 Advanced Micro Devices, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* ************************************************************************ */
#pragma once
#ifndef _HIPBLAS_HPP_
#define _HIPBLAS_HPP_
/* library headers */
#include "hipblas.h"
#include "type_utils.h"
#ifdef HIPBLAS_FORTRAN_CLIENTS
#include "hipblas_fortran.hpp"
#else
#include "hipblas_no_fortran.hpp"
#endif
#if not defined(__clang_major__)
#define CONSTEXPR constexpr
#else
#define CONSTEXPR
#endif
#define GET_MACRO(_1, _2, _3, _4, _5, NAME, ...) NAME
#define MAP2CF(...) GET_MACRO(__VA_ARGS__, MAP2CF5, MAP2CF4, MAP2CF3, dum2, dum1)(__VA_ARGS__)
// dual API C and FORTRAN
#define MAP2CF_D64(...) \
GET_MACRO(__VA_ARGS__, MAP2DCF5, MAP2DCF4, MAP2DCF3, dum2, dum1)(__VA_ARGS__)
#if defined(HIPBLAS_FORTRAN_CLIENTS)
#define MAP2CF3(FN, A, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN##Fortran
#define MAP2CF4(FN, A, B, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN##Fortran
#define MAP2CF5(FN, A, B, C, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN##Fortran
// dual API C and FORTRAN
#define MAP2DCF3(FN, A, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN##Fortran; \
template <> \
auto FN##_64 = PFN##_64; \
template <> \
auto FN##_64 = PFN##_64Fortran
#define MAP2DCF4(FN, A, B, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN##Fortran; \
template <> \
auto FN##_64 = PFN##_64; \
template <> \
auto FN##_64 = PFN##_64Fortran
#define MAP2DCF5(FN, A, B, C, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN##Fortran; \
template <> \
auto FN##_64 = PFN##_64; \
template <> \
auto FN##_64 = PFN##_64Fortran
#else
// mapping fortran and C to C API so we keep tests the same even without FORTRAN clients
#define MAP2CF3(FN, A, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN
#define MAP2CF4(FN, A, B, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN
#define MAP2CF5(FN, A, B, C, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN
// dual API C and FORTRAN
#define MAP2DCF3(FN, A, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN; \
template <> \
auto FN##_64 = PFN##_64; \
template <> \
auto FN##_64 = PFN##_64
#define MAP2DCF4(FN, A, B, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN; \
template <> \
auto FN##_64 = PFN##_64; \
template <> \
auto FN##_64 = PFN##_64
#define MAP2DCF5(FN, A, B, C, PFN) \
template <> \
auto FN = PFN; \
template <> \
auto FN = PFN; \
template <> \
auto FN##_64 = PFN##_64; \
template <> \
auto FN##_64 = PFN##_64
#endif
namespace
{
// Scal
template
hipblasStatus_t (*hipblasScal)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* alpha,
hipblas_internal_type* x,
int incx);
template
hipblasStatus_t (*hipblasScalBatched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* alpha,
hipblas_internal_type* const x[],
int incx,
int batch_count);
template
hipblasStatus_t (*hipblasScalStridedBatched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* alpha,
hipblas_internal_type* x,
int incx,
hipblasStride stridex,
int batch_count);
template
hipblasStatus_t (*hipblasScal_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* alpha,
hipblas_internal_type* x,
int64_t incx);
template
hipblasStatus_t (*hipblasScalBatched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* alpha,
hipblas_internal_type* const x[],
int64_t incx,
int64_t batch_count);
template
hipblasStatus_t (*hipblasScalStridedBatched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* alpha,
hipblas_internal_type* x,
int64_t incx,
hipblasStride stridex,
int64_t batch_count);
MAP2CF_D64(hipblasScal, float, float, hipblasSscal);
MAP2CF_D64(hipblasScal, double, double, hipblasDscal);
MAP2CF_D64(hipblasScal, std::complex, std::complex, hipblasCscal);
MAP2CF_D64(hipblasScal, std::complex, std::complex, hipblasZscal);
MAP2CF_D64(hipblasScal, std::complex, float, hipblasCsscal);
MAP2CF_D64(hipblasScal, std::complex, double, hipblasZdscal);
MAP2CF_D64(hipblasScalBatched, float, float, hipblasSscalBatched);
MAP2CF_D64(hipblasScalBatched, double, double, hipblasDscalBatched);
MAP2CF_D64(hipblasScalBatched, std::complex, std::complex, hipblasCscalBatched);
MAP2CF_D64(hipblasScalBatched, std::complex, std::complex, hipblasZscalBatched);
MAP2CF_D64(hipblasScalBatched, std::complex, float, hipblasCsscalBatched);
MAP2CF_D64(hipblasScalBatched, std::complex, double, hipblasZdscalBatched);
MAP2CF_D64(hipblasScalStridedBatched, float, float, hipblasSscalStridedBatched);
MAP2CF_D64(hipblasScalStridedBatched, double, double, hipblasDscalStridedBatched);
MAP2CF_D64(hipblasScalStridedBatched,
std::complex,
std::complex,
hipblasCscalStridedBatched);
MAP2CF_D64(hipblasScalStridedBatched,
std::complex,
std::complex,
hipblasZscalStridedBatched);
MAP2CF_D64(hipblasScalStridedBatched, std::complex, float, hipblasCsscalStridedBatched);
MAP2CF_D64(hipblasScalStridedBatched,
std::complex,
double,
hipblasZdscalStridedBatched);
// Copy
template
hipblasStatus_t (*hipblasCopy)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* x,
int incx,
hipblas_internal_type* y,
int incy);
template
hipblasStatus_t (*hipblasCopyBatched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* const x[],
int incx,
hipblas_internal_type* const y[],
int incy,
int batch_count);
template
hipblasStatus_t (*hipblasCopyStridedBatched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* x,
int incx,
hipblasStride stridex,
hipblas_internal_type* y,
int incy,
hipblasStride stridey,
int batch_count);
template
hipblasStatus_t (*hipblasCopy_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* x,
int64_t incx,
hipblas_internal_type* y,
int64_t incy);
template
hipblasStatus_t (*hipblasCopyBatched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* const x[],
int64_t incx,
hipblas_internal_type* const y[],
int64_t incy,
int64_t batch_count);
template
hipblasStatus_t (*hipblasCopyStridedBatched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* x,
int64_t incx,
hipblasStride stridex,
hipblas_internal_type* y,
int64_t incy,
hipblasStride stridey,
int64_t batch_count);
MAP2CF_D64(hipblasCopy, float, hipblasScopy);
MAP2CF_D64(hipblasCopy, double, hipblasDcopy);
MAP2CF_D64(hipblasCopy, std::complex, hipblasCcopy);
MAP2CF_D64(hipblasCopy, std::complex, hipblasZcopy);
MAP2CF_D64(hipblasCopyBatched, float, hipblasScopyBatched);
MAP2CF_D64(hipblasCopyBatched, double, hipblasDcopyBatched);
MAP2CF_D64(hipblasCopyBatched, std::complex, hipblasCcopyBatched);
MAP2CF_D64(hipblasCopyBatched, std::complex, hipblasZcopyBatched);
MAP2CF_D64(hipblasCopyStridedBatched, float, hipblasScopyStridedBatched);
MAP2CF_D64(hipblasCopyStridedBatched, double, hipblasDcopyStridedBatched);
MAP2CF_D64(hipblasCopyStridedBatched, std::complex, hipblasCcopyStridedBatched);
MAP2CF_D64(hipblasCopyStridedBatched, std::complex, hipblasZcopyStridedBatched);
// Swap
template
hipblasStatus_t (*hipblasSwap)(hipblasHandle_t handle,
int n,
hipblas_internal_type* x,
int incx,
hipblas_internal_type* y,
int incy);
template
hipblasStatus_t (*hipblasSwapBatched)(hipblasHandle_t handle,
int n,
hipblas_internal_type* const x[],
int incx,
hipblas_internal_type* const y[],
int incy,
int batch_count);
template
hipblasStatus_t (*hipblasSwapStridedBatched)(hipblasHandle_t handle,
int n,
hipblas_internal_type* x,
int incx,
hipblasStride stridex,
hipblas_internal_type* y,
int incy,
hipblasStride stridey,
int batch_count);
template
hipblasStatus_t (*hipblasSwap_64)(hipblasHandle_t handle,
int64_t n,
hipblas_internal_type* x,
int64_t incx,
hipblas_internal_type* y,
int64_t incy);
template
hipblasStatus_t (*hipblasSwapBatched_64)(hipblasHandle_t handle,
int64_t n,
hipblas_internal_type* const x[],
int64_t incx,
hipblas_internal_type* const y[],
int64_t incy,
int64_t batch_count);
template
hipblasStatus_t (*hipblasSwapStridedBatched_64)(hipblasHandle_t handle,
int64_t n,
hipblas_internal_type* x,
int64_t incx,
hipblasStride stridex,
hipblas_internal_type* y,
int64_t incy,
hipblasStride stridey,
int64_t batch_count);
MAP2CF_D64(hipblasSwap, float, hipblasSswap);
MAP2CF_D64(hipblasSwap, double, hipblasDswap);
MAP2CF_D64(hipblasSwap, std::complex, hipblasCswap);
MAP2CF_D64(hipblasSwap, std::complex, hipblasZswap);
MAP2CF_D64(hipblasSwapBatched, float, hipblasSswapBatched);
MAP2CF_D64(hipblasSwapBatched, double, hipblasDswapBatched);
MAP2CF_D64(hipblasSwapBatched, std::complex, hipblasCswapBatched);
MAP2CF_D64(hipblasSwapBatched, std::complex, hipblasZswapBatched);
MAP2CF_D64(hipblasSwapStridedBatched, float, hipblasSswapStridedBatched);
MAP2CF_D64(hipblasSwapStridedBatched, double, hipblasDswapStridedBatched);
MAP2CF_D64(hipblasSwapStridedBatched, std::complex, hipblasCswapStridedBatched);
MAP2CF_D64(hipblasSwapStridedBatched, std::complex, hipblasZswapStridedBatched);
// Dot
template
hipblasStatus_t (*hipblasDot)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* x,
int incx,
const hipblas_internal_type* y,
int incy,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasDotc)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* x,
int incx,
const hipblas_internal_type* y,
int incy,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasDotBatched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* const x[],
int incx,
const hipblas_internal_type* const y[],
int incy,
int batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasDotcBatched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* const x[],
int incx,
const hipblas_internal_type* const y[],
int incy,
int batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasDotStridedBatched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* x,
int incx,
hipblasStride stridex,
const hipblas_internal_type* y,
int incy,
hipblasStride stridey,
int batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasDotcStridedBatched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* x,
int incx,
hipblasStride stridex,
const hipblas_internal_type* y,
int incy,
hipblasStride stridey,
int batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasDot_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* x,
int64_t incx,
const hipblas_internal_type* y,
int64_t incy,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasDotc_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* x,
int64_t incx,
const hipblas_internal_type* y,
int64_t incy,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasDotBatched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* const x[],
int64_t incx,
const hipblas_internal_type* const y[],
int64_t incy,
int64_t batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasDotcBatched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* const x[],
int64_t incx,
const hipblas_internal_type* const y[],
int64_t incy,
int64_t batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasDotStridedBatched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* x,
int64_t incx,
hipblasStride stridex,
const hipblas_internal_type* y,
int64_t incy,
hipblasStride stridey,
int64_t batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasDotcStridedBatched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* x,
int64_t incx,
hipblasStride stridex,
const hipblas_internal_type* y,
int64_t incy,
hipblasStride stridey,
hipblas_internal_type batch_count,
hipblas_internal_type* result);
MAP2CF_D64(hipblasDot, hipblasHalf, hipblasHdot);
MAP2CF_D64(hipblasDot, hipblasBfloat16, hipblasBfdot);
MAP2CF_D64(hipblasDot, float, hipblasSdot);
MAP2CF_D64(hipblasDot, double, hipblasDdot);
MAP2CF_D64(hipblasDot, std::complex, hipblasCdotu);
MAP2CF_D64(hipblasDot, std::complex, hipblasZdotu);
MAP2CF_D64(hipblasDotc, std::complex, hipblasCdotc);
MAP2CF_D64(hipblasDotc, std::complex, hipblasZdotc);
MAP2CF_D64(hipblasDotBatched, hipblasHalf, hipblasHdotBatched);
MAP2CF_D64(hipblasDotBatched, hipblasBfloat16, hipblasBfdotBatched);
MAP2CF_D64(hipblasDotBatched, float, hipblasSdotBatched);
MAP2CF_D64(hipblasDotBatched, double, hipblasDdotBatched);
MAP2CF_D64(hipblasDotBatched, std::complex, hipblasCdotuBatched);
MAP2CF_D64(hipblasDotBatched, std::complex, hipblasZdotuBatched);
MAP2CF_D64(hipblasDotcBatched, std::complex, hipblasCdotcBatched);
MAP2CF_D64(hipblasDotcBatched, std::complex, hipblasZdotcBatched);
MAP2CF_D64(hipblasDotStridedBatched, hipblasHalf, hipblasHdotStridedBatched);
MAP2CF_D64(hipblasDotStridedBatched, hipblasBfloat16, hipblasBfdotStridedBatched);
MAP2CF_D64(hipblasDotStridedBatched, float, hipblasSdotStridedBatched);
MAP2CF_D64(hipblasDotStridedBatched, double, hipblasDdotStridedBatched);
MAP2CF_D64(hipblasDotStridedBatched, std::complex, hipblasCdotuStridedBatched);
MAP2CF_D64(hipblasDotStridedBatched, std::complex, hipblasZdotuStridedBatched);
MAP2CF_D64(hipblasDotcStridedBatched, std::complex, hipblasCdotcStridedBatched);
MAP2CF_D64(hipblasDotcStridedBatched, std::complex, hipblasZdotcStridedBatched);
// Asum
template
hipblasStatus_t (*hipblasAsum)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* x,
int incx,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasAsumBatched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* const x[],
int incx,
int batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasAsumStridedBatched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* x,
int incx,
hipblasStride stridex,
int batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasAsum_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* x,
int64_t incx,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasAsumBatched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* const x[],
int64_t incx,
int64_t batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasAsumStridedBatched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* x,
int64_t incx,
hipblasStride stridex,
int64_t batch_count,
hipblas_internal_type* result);
MAP2CF_D64(hipblasAsum, float, float, hipblasSasum);
MAP2CF_D64(hipblasAsum, double, double, hipblasDasum);
MAP2CF_D64(hipblasAsum, std::complex, float, hipblasScasum);
MAP2CF_D64(hipblasAsum, std::complex, double, hipblasDzasum);
MAP2CF_D64(hipblasAsumBatched, float, float, hipblasSasumBatched);
MAP2CF_D64(hipblasAsumBatched, double, double, hipblasDasumBatched);
MAP2CF_D64(hipblasAsumBatched, std::complex, float, hipblasScasumBatched);
MAP2CF_D64(hipblasAsumBatched, std::complex, double, hipblasDzasumBatched);
MAP2CF_D64(hipblasAsumStridedBatched, float, float, hipblasSasumStridedBatched);
MAP2CF_D64(hipblasAsumStridedBatched, double, double, hipblasDasumStridedBatched);
MAP2CF_D64(hipblasAsumStridedBatched, std::complex, float, hipblasScasumStridedBatched);
MAP2CF_D64(hipblasAsumStridedBatched,
std::complex,
double,
hipblasDzasumStridedBatched);
// nrm2
template
hipblasStatus_t (*hipblasNrm2)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* x,
int incx,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasNrm2Batched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* const x[],
int incx,
int batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasNrm2StridedBatched)(hipblasHandle_t handle,
int n,
const hipblas_internal_type* x,
int incx,
hipblasStride stridex,
int batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasNrm2_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* x,
int64_t incx,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasNrm2Batched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* const x[],
int64_t incx,
int64_t batch_count,
hipblas_internal_type* result);
template
hipblasStatus_t (*hipblasNrm2StridedBatched_64)(hipblasHandle_t handle,
int64_t n,
const hipblas_internal_type* x,
int64_t incx,
hipblasStride stridex,
int64_t batch_count,
hipblas_internal_type* result);
MAP2CF_D64(hipblasNrm2, float, float, hipblasSnrm2);
MAP2CF_D64(hipblasNrm2, double, double, hipblasDnrm2);
MAP2CF_D64(hipblasNrm2, std::complex, float, hipblasScnrm2);
MAP2CF_D64(hipblasNrm2, std::complex, double, hipblasDznrm2);
MAP2CF_D64(hipblasNrm2Batched, float, float, hipblasSnrm2Batched);
MAP2CF_D64(hipblasNrm2Batched, double, double, hipblasDnrm2Batched);
MAP2CF_D64(hipblasNrm2Batched, std::complex, float, hipblasScnrm2Batched);
MAP2CF_D64(hipblasNrm2Batched, std::complex, double, hipblasDznrm2Batched);
MAP2CF_D64(hipblasNrm2StridedBatched, float, float, hipblasSnrm2StridedBatched);
MAP2CF_D64(hipblasNrm2StridedBatched, double, double, hipblasDnrm2StridedBatched);
MAP2CF_D64(hipblasNrm2StridedBatched, std::complex, float, hipblasScnrm2StridedBatched);
MAP2CF_D64(hipblasNrm2StridedBatched,
std::complex,
double,
hipblasDznrm2StridedBatched);
// Rot
template
hipblasStatus_t (*hipblasRot)(hipblasHandle_t handle,
int n,
hipblas_internal_type* x,
int incx,
hipblas_internal_type* y,
int incy,
const hipblas_internal_type* c,
const hipblas_internal_type* s);
template
hipblasStatus_t (*hipblasRotBatched)(hipblasHandle_t handle,
int n,
hipblas_internal_type* const x[],
int incx,
hipblas_internal_type* const y[],
int incy,
const hipblas_internal_type* c,
const hipblas_internal_type* s,
int batch_count);
template
hipblasStatus_t (*hipblasRotStridedBatched)(hipblasHandle_t handle,
int n,
hipblas_internal_type* x,
int incx,
hipblasStride stridex,
hipblas_internal_type* y,
int incy,
hipblasStride stridey,
const hipblas_internal_type* c,
const hipblas_internal_type* s,
int batch_count);
template
hipblasStatus_t (*hipblasRot_64)(hipblasHandle_t handle,
int64_t n,
hipblas_internal_type* x,
int64_t incx,
hipblas_internal_type* y,
int64_t incy,
const hipblas_internal_type* c,
const hipblas_internal_type* s);
template
hipblasStatus_t (*hipblasRotBatched_64)(hipblasHandle_t handle,
int64_t n,
hipblas_internal_type* const x[],
int64_t incx,
hipblas_internal_type* const y[],
int64_t incy,
const hipblas_internal_type* c,
const hipblas_internal_type* s,
int64_t batch_count);
template
hipblasStatus_t (*hipblasRotStridedBatched_64)(hipblasHandle_t handle,
int64_t n,
hipblas_internal_type* x,
int64_t incx,
hipblasStride stridex,
hipblas_internal_type* y,
int64_t incy,
hipblasStride stridey,
const hipblas_internal_type* c,
const hipblas_internal_type* s,
int64_t batch_count);
MAP2CF_D64(hipblasRot, float, float, float, hipblasSrot);
MAP2CF_D64(hipblasRot, double, double, double, hipblasDrot);
MAP2CF_D64(hipblasRot, std::complex, float, std::complex, hipblasCrot);
MAP2CF_D64(hipblasRot, std::complex, double, std::complex, hipblasZrot);
MAP2CF_D64(hipblasRot, std::complex, float, float, hipblasCsrot);
MAP2CF_D64(hipblasRot, std::complex, double, double, hipblasZdrot);
MAP2CF_D64(hipblasRotBatched, float, float, float, hipblasSrotBatched);
MAP2CF_D64(hipblasRotBatched, double, double, double, hipblasDrotBatched);
MAP2CF_D64(
hipblasRotBatched, std::complex, float, std::complex, hipblasCrotBatched);
MAP2CF_D64(
hipblasRotBatched, std::complex, double, std::complex, hipblasZrotBatched);
MAP2CF_D64(hipblasRotBatched, std::complex, float, float, hipblasCsrotBatched);
MAP2CF_D64(hipblasRotBatched, std::complex, double, double, hipblasZdrotBatched);
MAP2CF_D64(hipblasRotStridedBatched, float, float, float, hipblasSrotStridedBatched);
MAP2CF_D64(hipblasRotStridedBatched, double, double, double, hipblasDrotStridedBatched);
MAP2CF_D64(hipblasRotStridedBatched,
std::complex,
float,
std::complex,
hipblasCrotStridedBatched);
MAP2CF_D64(hipblasRotStridedBatched,
std::complex,
double,
std::complex,
hipblasZrotStridedBatched);
MAP2CF_D64(
hipblasRotStridedBatched, std::complex, float, float, hipblasCsrotStridedBatched);
MAP2CF_D64(
hipblasRotStridedBatched, std::complex, double, double, hipblasZdrotStridedBatched);
// Rotg
template
hipblasStatus_t (*hipblasRotg)(hipblasHandle_t handle,
hipblas_internal_type* a,
hipblas_internal_type* b,
T2* c,
hipblas_internal_type* s);
template
hipblasStatus_t (*hipblasRotgBatched)(hipblasHandle_t handle,
hipblas_internal_type* const a[],
hipblas_internal_type* const b[],
hipblas_internal_type* const c[],
hipblas_internal_type* const s[],
int batch_count);
template
hipblasStatus_t (*hipblasRotgStridedBatched)(hipblasHandle_t handle,
hipblas_internal_type* a,
hipblasStride stridea,
hipblas_internal_type* b,
hipblasStride strideb,
hipblas_internal_type