Google Git
Sign in
android / platform / external / tensorflow / 67dd04ee2a1e6f53f379d8a44084866ee6382f6f / . / tensorflow / stream_executor / cuda / cublas_10_0.inc
blob: c24fd44c4f2613f5352cd4ac5c2eabf65ecfba9b [file] [log] [blame]
// Auto-generated, do not edit.
extern "C" {
cublasStatus_t CUBLASWINAPI cublasCreate_v2(cublasHandle_t *handle) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCreate_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle);
}
cublasStatus_t CUBLASWINAPI cublasDestroy_v2(cublasHandle_t handle) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDestroy_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle);
}
cublasStatus_t CUBLASWINAPI cublasGetVersion_v2(cublasHandle_t handle,
int *version) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetVersion_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, version);
}
cublasStatus_t CUBLASWINAPI cublasGetProperty(libraryPropertyType type,
int *value) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(libraryPropertyType, int *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetProperty");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(type, value);
}
cublasStatus_t CUBLASWINAPI cublasSetStream_v2(cublasHandle_t handle,
cudaStream_t streamId) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cudaStream_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetStream_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, streamId);
}
cublasStatus_t CUBLASWINAPI cublasGetStream_v2(cublasHandle_t handle,
cudaStream_t *streamId) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cudaStream_t *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetStream_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, streamId);
}
cublasStatus_t CUBLASWINAPI cublasGetPointerMode_v2(cublasHandle_t handle,
cublasPointerMode_t *mode) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasPointerMode_t *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetPointerMode_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, mode);
}
cublasStatus_t CUBLASWINAPI cublasSetPointerMode_v2(cublasHandle_t handle,
cublasPointerMode_t mode) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasPointerMode_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetPointerMode_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, mode);
}
cublasStatus_t CUBLASWINAPI cublasGetAtomicsMode(cublasHandle_t handle,
cublasAtomicsMode_t *mode) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasAtomicsMode_t *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetAtomicsMode");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, mode);
}
cublasStatus_t CUBLASWINAPI cublasSetAtomicsMode(cublasHandle_t handle,
cublasAtomicsMode_t mode) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasAtomicsMode_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetAtomicsMode");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, mode);
}
cublasStatus_t CUBLASWINAPI cublasGetMathMode(cublasHandle_t handle,
cublasMath_t *mode) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasMath_t *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetMathMode");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, mode);
}
cublasStatus_t CUBLASWINAPI cublasSetMathMode(cublasHandle_t handle,
cublasMath_t mode) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasMath_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetMathMode");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, mode);
}
cublasStatus_t CUBLASWINAPI cublasLoggerConfigure(int logIsOn, int logToStdOut,
int logToStdErr,
const char *logFileName) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, int, const char *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasLoggerConfigure");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(logIsOn, logToStdOut, logToStdErr, logFileName);
}
cublasStatus_t CUBLASWINAPI
cublasSetLoggerCallback(cublasLogCallback userCallback) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasLogCallback);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetLoggerCallback");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(userCallback);
}
cublasStatus_t CUBLASWINAPI
cublasGetLoggerCallback(cublasLogCallback *userCallback) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasLogCallback *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetLoggerCallback");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(userCallback);
}
cublasStatus_t CUBLASWINAPI cublasSetVector(int n, int elemSize, const void *x,
int incx, void *devicePtr,
int incy) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(int, int, const void *, int, void *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetVector");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(n, elemSize, x, incx, devicePtr, incy);
}
cublasStatus_t CUBLASWINAPI cublasGetVector(int n, int elemSize, const void *x,
int incx, void *y, int incy) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(int, int, const void *, int, void *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetVector");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(n, elemSize, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasSetMatrix(int rows, int cols, int elemSize,
const void *A, int lda, void *B,
int ldb) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, int, const void *,
int, void *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetMatrix");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(rows, cols, elemSize, A, lda, B, ldb);
}
cublasStatus_t CUBLASWINAPI cublasGetMatrix(int rows, int cols, int elemSize,
const void *A, int lda, void *B,
int ldb) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, int, const void *,
int, void *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetMatrix");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(rows, cols, elemSize, A, lda, B, ldb);
}
cublasStatus_t CUBLASWINAPI cublasSetVectorAsync(int n, int elemSize,
const void *hostPtr, int incx,
void *devicePtr, int incy,
cudaStream_t stream) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, const void *, int,
void *, int, cudaStream_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetVectorAsync");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(n, elemSize, hostPtr, incx, devicePtr, incy, stream);
}
cublasStatus_t CUBLASWINAPI cublasGetVectorAsync(int n, int elemSize,
const void *devicePtr,
int incx, void *hostPtr,
int incy,
cudaStream_t stream) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, const void *, int,
void *, int, cudaStream_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetVectorAsync");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(n, elemSize, devicePtr, incx, hostPtr, incy, stream);
}
cublasStatus_t CUBLASWINAPI cublasSetMatrixAsync(int rows, int cols,
int elemSize, const void *A,
int lda, void *B, int ldb,
cudaStream_t stream) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
int, int, int, const void *, int, void *, int, cudaStream_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetMatrixAsync");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(rows, cols, elemSize, A, lda, B, ldb, stream);
}
cublasStatus_t CUBLASWINAPI cublasGetMatrixAsync(int rows, int cols,
int elemSize, const void *A,
int lda, void *B, int ldb,
cudaStream_t stream) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
int, int, int, const void *, int, void *, int, cudaStream_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetMatrixAsync");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(rows, cols, elemSize, A, lda, B, ldb, stream);
}
void CUBLASWINAPI cublasXerbla(const char *srName, int info) {
using FuncPtr = void(CUBLASWINAPI *)(const char *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasXerbla");
if (!func_ptr) LogFatalSymbolNotFound("cublasXerbla");
return func_ptr(srName, info);
}
cublasStatus_t CUBLASWINAPI cublasNrm2Ex(cublasHandle_t handle, int n,
const void *x, cudaDataType xType,
int incx, void *result,
cudaDataType resultType,
cudaDataType executionType) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const void *, cudaDataType, int, void *,
cudaDataType, cudaDataType);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasNrm2Ex");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, xType, incx, result, resultType, executionType);
}
cublasStatus_t CUBLASWINAPI cublasSnrm2_v2(cublasHandle_t handle, int n,
const float *x, int incx,
float *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const float *, int, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSnrm2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasDnrm2_v2(cublasHandle_t handle, int n,
const double *x, int incx,
double *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const double *, int, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDnrm2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasScnrm2_v2(cublasHandle_t handle, int n,
const cuComplex *x, int incx,
float *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuComplex *, int, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasScnrm2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasDznrm2_v2(cublasHandle_t handle, int n,
const cuDoubleComplex *x, int incx,
double *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuDoubleComplex *, int, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDznrm2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasDotEx(cublasHandle_t handle, int n,
const void *x, cudaDataType xType,
int incx, const void *y,
cudaDataType yType, int incy,
void *result, cudaDataType resultType,
cudaDataType executionType) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const void *, cudaDataType, int, const void *,
cudaDataType, int, void *, cudaDataType, cudaDataType);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDotEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, xType, incx, y, yType, incy, result, resultType,
executionType);
}
cublasStatus_t CUBLASWINAPI cublasDotcEx(cublasHandle_t handle, int n,
const void *x, cudaDataType xType,
int incx, const void *y,
cudaDataType yType, int incy,
void *result, cudaDataType resultType,
cudaDataType executionType) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const void *, cudaDataType, int, const void *,
cudaDataType, int, void *, cudaDataType, cudaDataType);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDotcEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, xType, incx, y, yType, incy, result, resultType,
executionType);
}
cublasStatus_t CUBLASWINAPI cublasSdot_v2(cublasHandle_t handle, int n,
const float *x, int incx,
const float *y, int incy,
float *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const float *, int, const float *, int, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSdot_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, result);
}
cublasStatus_t CUBLASWINAPI cublasDdot_v2(cublasHandle_t handle, int n,
const double *x, int incx,
const double *y, int incy,
double *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const double *, int, const double *, int, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDdot_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, result);
}
cublasStatus_t CUBLASWINAPI cublasCdotu_v2(cublasHandle_t handle, int n,
const cuComplex *x, int incx,
const cuComplex *y, int incy,
cuComplex *result) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, const cuComplex *,
int, const cuComplex *, int, cuComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCdotu_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, result);
}
cublasStatus_t CUBLASWINAPI cublasCdotc_v2(cublasHandle_t handle, int n,
const cuComplex *x, int incx,
const cuComplex *y, int incy,
cuComplex *result) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, const cuComplex *,
int, const cuComplex *, int, cuComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCdotc_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, result);
}
cublasStatus_t CUBLASWINAPI cublasZdotu_v2(cublasHandle_t handle, int n,
const cuDoubleComplex *x, int incx,
const cuDoubleComplex *y, int incy,
cuDoubleComplex *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdotu_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, result);
}
cublasStatus_t CUBLASWINAPI cublasZdotc_v2(cublasHandle_t handle, int n,
const cuDoubleComplex *x, int incx,
const cuDoubleComplex *y, int incy,
cuDoubleComplex *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdotc_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, result);
}
cublasStatus_t CUBLASWINAPI
cublasScalEx(cublasHandle_t handle, int n,
const void *alpha, /* host or device pointer */
cudaDataType alphaType, void *x, cudaDataType xType, int incx,
cudaDataType executionType) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const void *, cudaDataType, void *, cudaDataType,
int, cudaDataType);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasScalEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, alphaType, x, xType, incx, executionType);
}
cublasStatus_t CUBLASWINAPI
cublasSscal_v2(cublasHandle_t handle, int n,
const float *alpha, /* host or device pointer */
float *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSscal_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, x, incx);
}
cublasStatus_t CUBLASWINAPI
cublasDscal_v2(cublasHandle_t handle, int n,
const double *alpha, /* host or device pointer */
double *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const double *, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDscal_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, x, incx);
}
cublasStatus_t CUBLASWINAPI
cublasCscal_v2(cublasHandle_t handle, int n,
const cuComplex *alpha, /* host or device pointer */
cuComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuComplex *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCscal_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, x, incx);
}
cublasStatus_t CUBLASWINAPI
cublasCsscal_v2(cublasHandle_t handle, int n,
const float *alpha, /* host or device pointer */
cuComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const float *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsscal_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, x, incx);
}
cublasStatus_t CUBLASWINAPI
cublasZscal_v2(cublasHandle_t handle, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
cuDoubleComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuDoubleComplex *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZscal_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, x, incx);
}
cublasStatus_t CUBLASWINAPI
cublasZdscal_v2(cublasHandle_t handle, int n,
const double *alpha, /* host or device pointer */
cuDoubleComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const double *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdscal_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasAxpyEx(
cublasHandle_t handle, int n,
const void *alpha, /* host or device pointer */
cudaDataType alphaType, const void *x, cudaDataType xType, int incx,
void *y, cudaDataType yType, int incy, cudaDataType executiontype) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const void *, cudaDataType, const void *,
cudaDataType, int, void *, cudaDataType, int, cudaDataType);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasAxpyEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, alphaType, x, xType, incx, y, yType, incy,
executiontype);
}
cublasStatus_t CUBLASWINAPI
cublasSaxpy_v2(cublasHandle_t handle, int n,
const float *alpha, /* host or device pointer */
const float *x, int incx, float *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const float *, const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSaxpy_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasDaxpy_v2(cublasHandle_t handle, int n,
const double *alpha, /* host or device pointer */
const double *x, int incx, double *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const double *, const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDaxpy_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasCaxpy_v2(cublasHandle_t handle, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *x, int incx, cuComplex *y, int incy) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, const cuComplex *,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCaxpy_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasZaxpy_v2(
cublasHandle_t handle, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *x, int incx, cuDoubleComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZaxpy_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, alpha, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasScopy_v2(cublasHandle_t handle, int n,
const float *x, int incx, float *y,
int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasScopy_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasDcopy_v2(cublasHandle_t handle, int n,
const double *x, int incx, double *y,
int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDcopy_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasCcopy_v2(cublasHandle_t handle, int n,
const cuComplex *x, int incx,
cuComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCcopy_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasZcopy_v2(cublasHandle_t handle, int n,
const cuDoubleComplex *x, int incx,
cuDoubleComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const cuDoubleComplex *, int,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZcopy_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasSswap_v2(cublasHandle_t handle, int n,
float *x, int incx, float *y,
int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, float *,
int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSswap_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasDswap_v2(cublasHandle_t handle, int n,
double *x, int incx, double *y,
int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, double *,
int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDswap_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasCswap_v2(cublasHandle_t handle, int n,
cuComplex *x, int incx, cuComplex *y,
int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCswap_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasZswap_v2(cublasHandle_t handle, int n,
cuDoubleComplex *x, int incx,
cuDoubleComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZswap_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasIsamax_v2(cublasHandle_t handle, int n,
const float *x, int incx,
int *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const float *, int, int *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIsamax_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasIdamax_v2(cublasHandle_t handle, int n,
const double *x, int incx,
int *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const double *, int, int *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIdamax_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasIcamax_v2(cublasHandle_t handle, int n,
const cuComplex *x, int incx,
int *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const cuComplex *, int, int *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIcamax_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasIzamax_v2(cublasHandle_t handle, int n,
const cuDoubleComplex *x, int incx,
int *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuDoubleComplex *, int, int *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIzamax_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasIsamin_v2(cublasHandle_t handle, int n,
const float *x, int incx,
int *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const float *, int, int *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIsamin_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasIdamin_v2(cublasHandle_t handle, int n,
const double *x, int incx,
int *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const double *, int, int *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIdamin_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasIcamin_v2(cublasHandle_t handle, int n,
const cuComplex *x, int incx,
int *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const cuComplex *, int, int *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIcamin_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasIzamin_v2(cublasHandle_t handle, int n,
const cuDoubleComplex *x, int incx,
int *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuDoubleComplex *, int, int *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIzamin_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasSasum_v2(cublasHandle_t handle, int n,
const float *x, int incx,
float *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const float *, int, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSasum_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasDasum_v2(cublasHandle_t handle, int n,
const double *x, int incx,
double *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int,
const double *, int, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDasum_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasScasum_v2(cublasHandle_t handle, int n,
const cuComplex *x, int incx,
float *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuComplex *, int, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasScasum_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI cublasDzasum_v2(cublasHandle_t handle, int n,
const cuDoubleComplex *x, int incx,
double *result) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuDoubleComplex *, int, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDzasum_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, result);
}
cublasStatus_t CUBLASWINAPI
cublasSrot_v2(cublasHandle_t handle, int n, float *x, int incx, float *y,
int incy, const float *c, /* host or device pointer */
const float *s) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, float *, int, float *,
int, const float *, const float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrot_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, c, s);
}
cublasStatus_t CUBLASWINAPI
cublasDrot_v2(cublasHandle_t handle, int n, double *x, int incx, double *y,
int incy, const double *c, /* host or device pointer */
const double *s) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, double *, int, double *, int, const double *,
const double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrot_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, c, s);
}
cublasStatus_t CUBLASWINAPI cublasCrot_v2(
cublasHandle_t handle, int n, cuComplex *x, int incx, cuComplex *y,
int incy, const float *c, /* host or device pointer */
const cuComplex *s) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, cuComplex *, int, cuComplex *, int, const float *,
const cuComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCrot_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, c, s);
}
cublasStatus_t CUBLASWINAPI cublasCsrot_v2(
cublasHandle_t handle, int n, cuComplex *x, int incx, cuComplex *y,
int incy, const float *c, /* host or device pointer */
const float *s) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, cuComplex *, int, cuComplex *, int, const float *,
const float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsrot_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, c, s);
}
cublasStatus_t CUBLASWINAPI cublasZrot_v2(
cublasHandle_t handle, int n, cuDoubleComplex *x, int incx,
cuDoubleComplex *y, int incy, const double *c, /* host or device pointer */
const cuDoubleComplex *s) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, cuDoubleComplex *, int, cuDoubleComplex *, int,
const double *, const cuDoubleComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZrot_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, c, s);
}
cublasStatus_t CUBLASWINAPI cublasZdrot_v2(
cublasHandle_t handle, int n, cuDoubleComplex *x, int incx,
cuDoubleComplex *y, int incy, const double *c, /* host or device pointer */
const double *s) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, cuDoubleComplex *, int, cuDoubleComplex *, int,
const double *, const double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdrot_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, c, s);
}
cublasStatus_t CUBLASWINAPI
cublasSrotg_v2(cublasHandle_t handle, float *a, /* host or device pointer */
float *b, /* host or device pointer */
float *c, /* host or device pointer */
float *s) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, float *,
float *, float *, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotg_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, a, b, c, s);
}
cublasStatus_t CUBLASWINAPI
cublasDrotg_v2(cublasHandle_t handle, double *a, /* host or device pointer */
double *b, /* host or device pointer */
double *c, /* host or device pointer */
double *s) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, double *,
double *, double *, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotg_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, a, b, c, s);
}
cublasStatus_t CUBLASWINAPI
cublasCrotg_v2(cublasHandle_t handle, cuComplex *a, /* host or device pointer */
cuComplex *b, /* host or device pointer */
float *c, /* host or device pointer */
cuComplex *s) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cuComplex *, cuComplex *, float *, cuComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCrotg_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, a, b, c, s);
}
cublasStatus_t CUBLASWINAPI cublasZrotg_v2(
cublasHandle_t handle, cuDoubleComplex *a, /* host or device pointer */
cuDoubleComplex *b, /* host or device pointer */
double *c, /* host or device pointer */
cuDoubleComplex *s) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cuDoubleComplex *, cuDoubleComplex *, double *,
cuDoubleComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZrotg_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, a, b, c, s);
}
cublasStatus_t CUBLASWINAPI cublasSrotm_v2(cublasHandle_t handle, int n,
float *x, int incx, float *y,
int incy, const float *param) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, float *, int, float *, int, const float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, param);
}
cublasStatus_t CUBLASWINAPI cublasDrotm_v2(cublasHandle_t handle, int n,
double *x, int incx, double *y,
int incy, const double *param) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, double *, int, double *, int, const double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, x, incx, y, incy, param);
}
cublasStatus_t CUBLASWINAPI
cublasSrotmg_v2(cublasHandle_t handle, float *d1, /* host or device pointer */
float *d2, /* host or device pointer */
float *x1, /* host or device pointer */
const float *y1, /* host or device pointer */
float *param) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, float *, float *, float *, const float *, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotmg_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, d1, d2, x1, y1, param);
}
cublasStatus_t CUBLASWINAPI
cublasDrotmg_v2(cublasHandle_t handle, double *d1, /* host or device pointer */
double *d2, /* host or device pointer */
double *x1, /* host or device pointer */
const double *y1, /* host or device pointer */
double *param) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, double *, double *, double *, const double *, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotmg_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, d1, d2, x1, y1, param);
}
cublasStatus_t CUBLASWINAPI
cublasSgemv_v2(cublasHandle_t handle, cublasOperation_t trans, int m, int n,
const float *alpha, /* host or device pointer */
const float *A, int lda, const float *x, int incx,
const float *beta, /* host or device pointer */
float *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, const float *, const float *,
int, const float *, int, const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasDgemv_v2(cublasHandle_t handle, cublasOperation_t trans, int m, int n,
const double *alpha, /* host or device pointer */
const double *A, int lda, const double *x, int incx,
const double *beta, /* host or device pointer */
double *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, const double *,
const double *, int, const double *, int, const double *, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasCgemv_v2(cublasHandle_t handle, cublasOperation_t trans, int m, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *x, int incx,
const cuComplex *beta, /* host or device pointer */
cuComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, const cuComplex *,
const cuComplex *, int, const cuComplex *, int, const cuComplex *,
cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasZgemv_v2(
cublasHandle_t handle, cublasOperation_t trans, int m, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, const cuDoubleComplex *, int,
const cuDoubleComplex *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasSgbmv_v2(cublasHandle_t handle, cublasOperation_t trans, int m, int n,
int kl, int ku, const float *alpha, /* host or device pointer */
const float *A, int lda, const float *x, int incx,
const float *beta, /* host or device pointer */
float *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, int, int, const float *,
const float *, int, const float *, int, const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y,
incy);
}
cublasStatus_t CUBLASWINAPI
cublasDgbmv_v2(cublasHandle_t handle, cublasOperation_t trans, int m, int n,
int kl, int ku, const double *alpha, /* host or device pointer */
const double *A, int lda, const double *x, int incx,
const double *beta, /* host or device pointer */
double *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, int, int, const double *,
const double *, int, const double *, int, const double *, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y,
incy);
}
cublasStatus_t CUBLASWINAPI cublasCgbmv_v2(
cublasHandle_t handle, cublasOperation_t trans, int m, int n, int kl,
int ku, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *x, int incx,
const cuComplex *beta, /* host or device pointer */
cuComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, int, int, const cuComplex *,
const cuComplex *, int, const cuComplex *, int, const cuComplex *,
cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y,
incy);
}
cublasStatus_t CUBLASWINAPI cublasZgbmv_v2(
cublasHandle_t handle, cublasOperation_t trans, int m, int n, int kl,
int ku, const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y,
incy);
}
cublasStatus_t CUBLASWINAPI cublasStrmv_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
cublasDiagType_t diag, int n, const float *A, int lda, float *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasDtrmv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n,
const double *A, int lda, double *x,
int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasCtrmv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n,
const cuComplex *A, int lda,
cuComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasZtrmv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n,
const cuDoubleComplex *A, int lda,
cuDoubleComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasStbmv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n, int k,
const float *A, int lda, float *x,
int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, int, const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasDtbmv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n, int k,
const double *A, int lda, double *x,
int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, int, const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasCtbmv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n, int k,
const cuComplex *A, int lda,
cuComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, int, const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasZtbmv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n, int k,
const cuDoubleComplex *A, int lda,
cuDoubleComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasStpmv_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
cublasDiagType_t diag, int n, const float *AP, float *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStpmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, AP, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasDtpmv_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
cublasDiagType_t diag, int n, const double *AP, double *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const double *, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtpmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, AP, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasCtpmv_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
cublasDiagType_t diag, int n, const cuComplex *AP, cuComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const cuComplex *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtpmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, AP, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasZtpmv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n,
const cuDoubleComplex *AP,
cuDoubleComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const cuDoubleComplex *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtpmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, AP, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasStrsv_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
cublasDiagType_t diag, int n, const float *A, int lda, float *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasDtrsv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n,
const double *A, int lda, double *x,
int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasCtrsv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n,
const cuComplex *A, int lda,
cuComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasZtrsv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n,
const cuDoubleComplex *A, int lda,
cuDoubleComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasStpsv_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
cublasDiagType_t diag, int n, const float *AP, float *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStpsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, AP, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasDtpsv_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
cublasDiagType_t diag, int n, const double *AP, double *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const double *, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtpsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, AP, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasCtpsv_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
cublasDiagType_t diag, int n, const cuComplex *AP, cuComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const cuComplex *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtpsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, AP, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasZtpsv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n,
const cuDoubleComplex *AP,
cuDoubleComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, const cuDoubleComplex *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtpsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, AP, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasStbsv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n, int k,
const float *A, int lda, float *x,
int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, int, const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStbsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasDtbsv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n, int k,
const double *A, int lda, double *x,
int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, int, const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtbsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasCtbsv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n, int k,
const cuComplex *A, int lda,
cuComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, int, const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtbsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI cublasZtbsv_v2(cublasHandle_t handle,
cublasFillMode_t uplo,
cublasOperation_t trans,
cublasDiagType_t diag, int n, int k,
const cuDoubleComplex *A, int lda,
cuDoubleComplex *x, int incx) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t,
int, int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtbsv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx);
}
cublasStatus_t CUBLASWINAPI
cublasSsymv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const float *alpha, /* host or device pointer */
const float *A, int lda, const float *x, int incx,
const float *beta, /* host or device pointer */
float *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const float *, const float *, int,
const float *, int, const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsymv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasDsymv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const double *alpha, /* host or device pointer */
const double *A, int lda, const double *x, int incx,
const double *beta, /* host or device pointer */
double *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const double *, const double *,
int, const double *, int, const double *, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsymv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasCsymv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *x, int incx,
const cuComplex *beta, /* host or device pointer */
cuComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuComplex *,
const cuComplex *, int, const cuComplex *, int, const cuComplex *,
cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsymv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasZsymv_v2(
cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, const cuDoubleComplex *, int,
const cuDoubleComplex *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsymv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasChemv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *x, int incx,
const cuComplex *beta, /* host or device pointer */
cuComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuComplex *,
const cuComplex *, int, const cuComplex *, int, const cuComplex *,
cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChemv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasZhemv_v2(
cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, const cuDoubleComplex *, int,
const cuDoubleComplex *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhemv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasSsbmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, int k,
const float *alpha, /* host or device pointer */
const float *A, int lda, const float *x, int incx,
const float *beta, /* host or device pointer */
float *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, int, const float *, const float *,
int, const float *, int, const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasDsbmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, int k,
const double *alpha, /* host or device pointer */
const double *A, int lda, const double *x, int incx,
const double *beta, /* host or device pointer */
double *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, int, const double *,
const double *, int, const double *, int, const double *, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasChbmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, int k,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *x, int incx,
const cuComplex *beta, /* host or device pointer */
cuComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, int, const cuComplex *,
const cuComplex *, int, const cuComplex *, int, const cuComplex *,
cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasZhbmv_v2(
cublasHandle_t handle, cublasFillMode_t uplo, int n, int k,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, const cuDoubleComplex *, int,
const cuDoubleComplex *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhbmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasSspmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const float *alpha, /* host or device pointer */
const float *AP, const float *x, int incx,
const float *beta, /* host or device pointer */
float *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const float *, const float *,
const float *, int, const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, AP, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasDspmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const double *alpha, /* host or device pointer */
const double *AP, const double *x, int incx,
const double *beta, /* host or device pointer */
double *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const double *, const double *,
const double *, int, const double *, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, AP, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasChpmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *AP, const cuComplex *x, int incx,
const cuComplex *beta, /* host or device pointer */
cuComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuComplex *,
const cuComplex *, const cuComplex *, int, const cuComplex *, cuComplex *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, AP, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI
cublasZhpmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *AP, const cuDoubleComplex *x, int incx,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *y, int incy) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpmv_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, AP, x, incx, beta, y, incy);
}
cublasStatus_t CUBLASWINAPI cublasSger_v2(
cublasHandle_t handle, int m, int n,
const float *alpha, /* host or device pointer */
const float *x, int incx, const float *y, int incy, float *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, int, const float *, const float *, int,
const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSger_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI cublasDger_v2(
cublasHandle_t handle, int m, int n,
const double *alpha, /* host or device pointer */
const double *x, int incx, const double *y, int incy, double *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, int, const double *, const double *, int,
const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDger_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasCgeru_v2(cublasHandle_t handle, int m, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *x, int incx, const cuComplex *y, int incy,
cuComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, int, const cuComplex *, const cuComplex *, int,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgeru_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasCgerc_v2(cublasHandle_t handle, int m, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *x, int incx, const cuComplex *y, int incy,
cuComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, int, const cuComplex *, const cuComplex *, int,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgerc_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasZgeru_v2(cublasHandle_t handle, int m, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *x, int incx, const cuDoubleComplex *y,
int incy, cuDoubleComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, const cuDoubleComplex *, int,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgeru_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasZgerc_v2(cublasHandle_t handle, int m, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *x, int incx, const cuDoubleComplex *y,
int incy, cuDoubleComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, const cuDoubleComplex *, int,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgerc_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasSsyr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const float *alpha, /* host or device pointer */
const float *x, int incx, float *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const float *, const float *, int,
float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasDsyr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const double *alpha, /* host or device pointer */
const double *x, int incx, double *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const double *, const double *,
int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasCsyr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *x, int incx, cuComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuComplex *,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyr_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasZsyr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *x, int incx, cuDoubleComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyr_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasCher_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const float *alpha, /* host or device pointer */
const cuComplex *x, int incx, cuComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const float *, const cuComplex *,
int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasZher_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const double *alpha, /* host or device pointer */
const cuDoubleComplex *x, int incx, cuDoubleComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const double *,
const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasSspr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const float *alpha, /* host or device pointer */
const float *x, int incx, float *AP) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const float *, const float *, int,
float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspr_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, AP);
}
cublasStatus_t CUBLASWINAPI
cublasDspr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const double *alpha, /* host or device pointer */
const double *x, int incx, double *AP) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const double *, const double *,
int, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspr_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, AP);
}
cublasStatus_t CUBLASWINAPI
cublasChpr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const float *alpha, /* host or device pointer */
const cuComplex *x, int incx, cuComplex *AP) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const float *, const cuComplex *,
int, cuComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpr_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, AP);
}
cublasStatus_t CUBLASWINAPI
cublasZhpr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const double *alpha, /* host or device pointer */
const cuDoubleComplex *x, int incx, cuDoubleComplex *AP) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const double *,
const cuDoubleComplex *, int, cuDoubleComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpr_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, AP);
}
cublasStatus_t CUBLASWINAPI cublasSsyr2_v2(
cublasHandle_t handle, cublasFillMode_t uplo, int n,
const float *alpha, /* host or device pointer */
const float *x, int incx, const float *y, int incy, float *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const float *, const float *, int,
const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI cublasDsyr2_v2(
cublasHandle_t handle, cublasFillMode_t uplo, int n,
const double *alpha, /* host or device pointer */
const double *x, int incx, const double *y, int incy, double *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const double *, const double *,
int, const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasCsyr2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *x, int incx, const cuComplex *y, int incy,
cuComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuComplex *,
const cuComplex *, int, const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyr2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasZsyr2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *x, int incx, const cuDoubleComplex *y,
int incy, cuDoubleComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, const cuDoubleComplex *, int,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyr2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasCher2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *x, int incx, const cuComplex *y, int incy,
cuComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuComplex *,
const cuComplex *, int, const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasZher2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *x, int incx, const cuDoubleComplex *y,
int incy, cuDoubleComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, const cuDoubleComplex *, int,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda);
}
cublasStatus_t CUBLASWINAPI
cublasSspr2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const float *alpha, /* host or device pointer */
const float *x, int incx, const float *y, int incy, float *AP) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const float *, const float *, int,
const float *, int, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspr2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, AP);
}
cublasStatus_t CUBLASWINAPI cublasDspr2_v2(
cublasHandle_t handle, cublasFillMode_t uplo, int n,
const double *alpha, /* host or device pointer */
const double *x, int incx, const double *y, int incy, double *AP) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const double *, const double *,
int, const double *, int, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspr2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, AP);
}
cublasStatus_t CUBLASWINAPI cublasChpr2_v2(
cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *x, int incx, const cuComplex *y, int incy, cuComplex *AP) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuComplex *,
const cuComplex *, int, const cuComplex *, int, cuComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpr2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, AP);
}
cublasStatus_t CUBLASWINAPI
cublasZhpr2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *x, int incx, const cuDoubleComplex *y,
int incy, cuDoubleComplex *AP) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, const cuDoubleComplex *, int,
cuDoubleComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpr2_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, AP);
}
cublasStatus_t CUBLASWINAPI cublasSgemm_v2(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const float *alpha, /* host or device pointer */
const float *A, int lda, const float *B, int ldb,
const float *beta, /* host or device pointer */
float *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const float *, const float *, int, const float *, int, const float *,
float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta,
C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasDgemm_v2(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const double *alpha, /* host or device pointer */
const double *A, int lda, const double *B, int ldb,
const double *beta, /* host or device pointer */
double *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const double *, const double *, int, const double *, int, const double *,
double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta,
C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasCgemm_v2(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *B, int ldb,
const cuComplex *beta, /* host or device pointer */
cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuComplex *, const cuComplex *, int, const cuComplex *, int,
const cuComplex *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta,
C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasCgemm3m(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *B, int ldb,
const cuComplex *beta, /* host or device pointer */
cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuComplex *, const cuComplex *, int, const cuComplex *, int,
const cuComplex *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm3m");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta,
C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasCgemm3mEx(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const cuComplex *alpha, const void *A,
cudaDataType Atype, int lda, const void *B, cudaDataType Btype, int ldb,
const cuComplex *beta, void *C, cudaDataType Ctype, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuComplex *, const void *, cudaDataType, int, const void *,
cudaDataType, int, const cuComplex *, void *, cudaDataType, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm3mEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, Atype, lda, B,
Btype, ldb, beta, C, Ctype, ldc);
}
cublasStatus_t CUBLASWINAPI cublasZgemm_v2(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta,
C, ldc);
}
cublasStatus_t CUBLASWINAPI
cublasZgemm3m(cublasHandle_t handle, cublasOperation_t transa,
cublasOperation_t transb, int m, int n, int k,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *B,
int ldb, const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemm3m");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta,
C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasSgemmEx(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const float *alpha, /* host or device pointer */
const void *A, cudaDataType Atype, int lda, const void *B,
cudaDataType Btype, int ldb, const float *beta, /* host or device pointer */
void *C, cudaDataType Ctype, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const float *, const void *, cudaDataType, int, const void *,
cudaDataType, int, const float *, void *, cudaDataType, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemmEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, Atype, lda, B,
Btype, ldb, beta, C, Ctype, ldc);
}
cublasStatus_t CUBLASWINAPI cublasGemmEx(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const void *alpha, /* host or device pointer */
const void *A, cudaDataType Atype, int lda, const void *B,
cudaDataType Btype, int ldb, const void *beta, /* host or device pointer */
void *C, cudaDataType Ctype, int ldc, cudaDataType computeType,
cublasGemmAlgo_t algo) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const void *, const void *, cudaDataType, int, const void *, cudaDataType,
int, const void *, void *, cudaDataType, int, cudaDataType,
cublasGemmAlgo_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGemmEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, Atype, lda, B,
Btype, ldb, beta, C, Ctype, ldc, computeType, algo);
}
cublasStatus_t CUBLASWINAPI cublasCgemmEx(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const cuComplex *alpha, const void *A,
cudaDataType Atype, int lda, const void *B, cudaDataType Btype, int ldb,
const cuComplex *beta, void *C, cudaDataType Ctype, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuComplex *, const void *, cudaDataType, int, const void *,
cudaDataType, int, const cuComplex *, void *, cudaDataType, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemmEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, Atype, lda, B,
Btype, ldb, beta, C, Ctype, ldc);
}
cublasStatus_t CUBLASWINAPI cublasUint8gemmBias(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
cublasOperation_t transc, int m, int n, int k, const unsigned char *A,
int A_bias, int lda, const unsigned char *B, int B_bias, int ldb,
unsigned char *C, int C_bias, int ldc, int C_mult, int C_shift) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, cublasOperation_t,
int, int, int, const unsigned char *, int, int, const unsigned char *,
int, int, unsigned char *, int, int, int, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasUint8gemmBias");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, transc, m, n, k, A, A_bias, lda, B,
B_bias, ldb, C, C_bias, ldc, C_mult, C_shift);
}
cublasStatus_t CUBLASWINAPI cublasSsyrk_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const float *alpha, /* host or device pointer */
const float *A, int lda, const float *beta, /* host or device pointer */
float *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const float *, const float *, int, const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyrk_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasDsyrk_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const double *alpha, /* host or device pointer */
const double *A, int lda, const double *beta, /* host or device pointer */
double *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const double *, const double *, int, const double *, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyrk_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasCsyrk_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda,
const cuComplex *beta, /* host or device pointer */
cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuComplex *, const cuComplex *, int, const cuComplex *, cuComplex *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyrk_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasZsyrk_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyrk_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasCsyrkEx(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuComplex *alpha, /* host or device pointer */
const void *A, cudaDataType Atype, int lda,
const cuComplex *beta, /* host or device pointer */
void *C, cudaDataType Ctype, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuComplex *, const void *, cudaDataType, int, const cuComplex *,
void *, cudaDataType, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyrkEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C,
Ctype, ldc);
}
cublasStatus_t CUBLASWINAPI cublasCsyrk3mEx(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuComplex *alpha, const void *A, cudaDataType Atype,
int lda, const cuComplex *beta, void *C, cudaDataType Ctype, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuComplex *, const void *, cudaDataType, int, const cuComplex *,
void *, cudaDataType, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyrk3mEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C,
Ctype, ldc);
}
cublasStatus_t CUBLASWINAPI cublasCherk_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const float *alpha, /* host or device pointer */
const cuComplex *A, int lda, const float *beta, /* host or device pointer */
cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const float *, const cuComplex *, int, const float *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCherk_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasZherk_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const double *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda,
const double *beta, /* host or device pointer */
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const double *, const cuDoubleComplex *, int, const double *,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZherk_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasCherkEx(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const float *alpha, /* host or device pointer */
const void *A, cudaDataType Atype, int lda,
const float *beta, /* host or device pointer */
void *C, cudaDataType Ctype, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const float *, const void *, cudaDataType, int, const float *, void *,
cudaDataType, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCherkEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C,
Ctype, ldc);
}
cublasStatus_t CUBLASWINAPI cublasCherk3mEx(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const float *alpha, const void *A, cudaDataType Atype,
int lda, const float *beta, void *C, cudaDataType Ctype, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const float *, const void *, cudaDataType, int, const float *, void *,
cudaDataType, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCherk3mEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C,
Ctype, ldc);
}
cublasStatus_t CUBLASWINAPI cublasSsyr2k_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const float *alpha, /* host or device pointer */
const float *A, int lda, const float *B, int ldb,
const float *beta, /* host or device pointer */
float *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const float *, const float *, int, const float *, int, const float *,
float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr2k_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasDsyr2k_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const double *alpha, /* host or device pointer */
const double *A, int lda, const double *B, int ldb,
const double *beta, /* host or device pointer */
double *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const double *, const double *, int, const double *, int, const double *,
double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr2k_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasCsyr2k_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *B, int ldb,
const cuComplex *beta, /* host or device pointer */
cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuComplex *, const cuComplex *, int, const cuComplex *, int,
const cuComplex *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyr2k_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasZsyr2k_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyr2k_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasCher2k_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *B, int ldb,
const float *beta, /* host or device pointer */
cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuComplex *, const cuComplex *, int, const cuComplex *, int,
const float *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher2k_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasZher2k_v2(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb,
const double *beta, /* host or device pointer */
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, const double *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher2k_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasSsyrkx(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const float *alpha, /* host or device pointer */
const float *A, int lda, const float *B, int ldb,
const float *beta, /* host or device pointer */
float *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const float *, const float *, int, const float *, int, const float *,
float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyrkx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasDsyrkx(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const double *alpha, /* host or device pointer */
const double *A, int lda, const double *B, int ldb,
const double *beta, /* host or device pointer */
double *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const double *, const double *, int, const double *, int, const double *,
double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyrkx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasCsyrkx(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *B, int ldb,
const cuComplex *beta, /* host or device pointer */
cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuComplex *, const cuComplex *, int, const cuComplex *, int,
const cuComplex *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyrkx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasZsyrkx(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyrkx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasCherkx(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *B, int ldb,
const float *beta, /* host or device pointer */
cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuComplex *, const cuComplex *, int, const cuComplex *, int,
const float *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCherkx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasZherkx(
cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans,
int n, int k, const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb,
const double *beta, /* host or device pointer */
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, const double *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZherkx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasSsymm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m,
int n, const float *alpha, /* host or device pointer */
const float *A, int lda, const float *B, int ldb,
const float *beta, /* host or device pointer */
float *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int,
const float *, const float *, int, const float *, int, const float *,
float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsymm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasDsymm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m,
int n, const double *alpha, /* host or device pointer */
const double *A, int lda, const double *B, int ldb,
const double *beta, /* host or device pointer */
double *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int,
const double *, const double *, int, const double *, int, const double *,
double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsymm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasCsymm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m,
int n, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *B, int ldb,
const cuComplex *beta, /* host or device pointer */
cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int,
const cuComplex *, const cuComplex *, int, const cuComplex *, int,
const cuComplex *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsymm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasZsymm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m,
int n, const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsymm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasChemm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m,
int n, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *B, int ldb,
const cuComplex *beta, /* host or device pointer */
cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int,
const cuComplex *, const cuComplex *, int, const cuComplex *, int,
const cuComplex *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChemm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasZhemm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m,
int n, const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhemm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasStrsm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const float *alpha, /* host or device pointer */
const float *A, int lda, float *B, int ldb) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const float *, const float *, int, float *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrsm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb);
}
cublasStatus_t CUBLASWINAPI cublasDtrsm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const double *alpha, /* host or device pointer */
const double *A, int lda, double *B, int ldb) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const double *, const double *, int, double *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrsm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb);
}
cublasStatus_t CUBLASWINAPI cublasCtrsm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, cuComplex *B, int ldb) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const cuComplex *, const cuComplex *, int,
cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrsm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb);
}
cublasStatus_t CUBLASWINAPI cublasZtrsm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, cuDoubleComplex *B, int ldb) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrsm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb);
}
cublasStatus_t CUBLASWINAPI cublasStrmm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const float *alpha, /* host or device pointer */
const float *A, int lda, const float *B, int ldb, float *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const float *, const float *, int,
const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrmm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb,
C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasDtrmm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const double *alpha, /* host or device pointer */
const double *A, int lda, const double *B, int ldb, double *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const double *, const double *, int,
const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrmm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb,
C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasCtrmm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, const cuComplex *B, int ldb, cuComplex *C,
int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const cuComplex *, const cuComplex *, int,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrmm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb,
C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasZtrmm_v2(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb,
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const cuDoubleComplex *,
const cuDoubleComplex *, int, const cuDoubleComplex *, int,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrmm_v2");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb,
C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasSgemmBatched(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const float *alpha, /* host or device pointer */
const float *const Aarray[], int lda, const float *const Barray[], int ldb,
const float *beta, /* host or device pointer */
float *const Carray[], int ldc, int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const float *, const float *const[], int, const float *const[], int,
const float *, float *const[], int, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemmBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, lda, Barray,
ldb, beta, Carray, ldc, batchCount);
}
cublasStatus_t CUBLASWINAPI cublasDgemmBatched(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const double *alpha, /* host or device pointer */
const double *const Aarray[], int lda, const double *const Barray[],
int ldb, const double *beta, /* host or device pointer */
double *const Carray[], int ldc, int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const double *, const double *const[], int, const double *const[], int,
const double *, double *const[], int, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemmBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, lda, Barray,
ldb, beta, Carray, ldc, batchCount);
}
cublasStatus_t CUBLASWINAPI cublasCgemmBatched(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const cuComplex *alpha, /* host or device pointer */
const cuComplex *const Aarray[], int lda, const cuComplex *const Barray[],
int ldb, const cuComplex *beta, /* host or device pointer */
cuComplex *const Carray[], int ldc, int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuComplex *, const cuComplex *const[], int,
const cuComplex *const[], int, const cuComplex *, cuComplex *const[], int,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemmBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, lda, Barray,
ldb, beta, Carray, ldc, batchCount);
}
cublasStatus_t CUBLASWINAPI cublasCgemm3mBatched(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const cuComplex *alpha, /* host or device pointer */
const cuComplex *const Aarray[], int lda, const cuComplex *const Barray[],
int ldb, const cuComplex *beta, /* host or device pointer */
cuComplex *const Carray[], int ldc, int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuComplex *, const cuComplex *const[], int,
const cuComplex *const[], int, const cuComplex *, cuComplex *const[], int,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm3mBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, lda, Barray,
ldb, beta, Carray, ldc, batchCount);
}
cublasStatus_t CUBLASWINAPI
cublasZgemmBatched(cublasHandle_t handle, cublasOperation_t transa,
cublasOperation_t transb, int m, int n, int k,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *const Aarray[], int lda,
const cuDoubleComplex *const Barray[], int ldb,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *const Carray[], int ldc, int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuDoubleComplex *, const cuDoubleComplex *const[], int,
const cuDoubleComplex *const[], int, const cuDoubleComplex *,
cuDoubleComplex *const[], int, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemmBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, lda, Barray,
ldb, beta, Carray, ldc, batchCount);
}
cublasStatus_t CUBLASWINAPI cublasGemmBatchedEx(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const void *alpha, /* host or device pointer */
const void *const Aarray[], cudaDataType Atype, int lda,
const void *const Barray[], cudaDataType Btype, int ldb,
const void *beta, /* host or device pointer */
void *const Carray[], cudaDataType Ctype, int ldc, int batchCount,
cudaDataType computeType, cublasGemmAlgo_t algo) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const void *, const void *const[], cudaDataType, int, const void *const[],
cudaDataType, int, const void *, void *const[], cudaDataType, int, int,
cudaDataType, cublasGemmAlgo_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGemmBatchedEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, Atype, lda,
Barray, Btype, ldb, beta, Carray, Ctype, ldc, batchCount,
computeType, algo);
}
cublasStatus_t CUBLASWINAPI cublasGemmStridedBatchedEx(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const void *alpha, /* host or device pointer */
const void *A, cudaDataType Atype, int lda,
long long int strideA, /* purposely signed */
const void *B, cudaDataType Btype, int ldb, long long int strideB,
const void *beta, /* host or device pointer */
void *C, cudaDataType Ctype, int ldc, long long int strideC, int batchCount,
cudaDataType computeType, cublasGemmAlgo_t algo) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const void *, const void *, cudaDataType, int, long long, const void *,
cudaDataType, int, long long, const void *, void *, cudaDataType, int,
long long, int, cudaDataType, cublasGemmAlgo_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGemmStridedBatchedEx");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, Atype, lda,
strideA, B, Btype, ldb, strideB, beta, C, Ctype, ldc, strideC,
batchCount, computeType, algo);
}
cublasStatus_t CUBLASWINAPI cublasSgemmStridedBatched(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const float *alpha, /* host or device pointer */
const float *A, int lda, long long int strideA, /* purposely signed */
const float *B, int ldb, long long int strideB,
const float *beta, /* host or device pointer */
float *C, int ldc, long long int strideC, int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const float *, const float *, int, long long, const float *, int,
long long, const float *, float *, int, long long, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemmStridedBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, strideA, B,
ldb, strideB, beta, C, ldc, strideC, batchCount);
}
cublasStatus_t CUBLASWINAPI cublasDgemmStridedBatched(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const double *alpha, /* host or device pointer */
const double *A, int lda, long long int strideA, /* purposely signed */
const double *B, int ldb, long long int strideB,
const double *beta, /* host or device pointer */
double *C, int ldc, long long int strideC, int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const double *, const double *, int, long long, const double *, int,
long long, const double *, double *, int, long long, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemmStridedBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, strideA, B,
ldb, strideB, beta, C, ldc, strideC, batchCount);
}
cublasStatus_t CUBLASWINAPI cublasCgemmStridedBatched(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, long long int strideA, /* purposely signed */
const cuComplex *B, int ldb, long long int strideB,
const cuComplex *beta, /* host or device pointer */
cuComplex *C, int ldc, long long int strideC, int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuComplex *, const cuComplex *, int, long long, const cuComplex *,
int, long long, const cuComplex *, cuComplex *, int, long long, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemmStridedBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, strideA, B,
ldb, strideB, beta, C, ldc, strideC, batchCount);
}
cublasStatus_t CUBLASWINAPI cublasCgemm3mStridedBatched(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda, long long int strideA, /* purposely signed */
const cuComplex *B, int ldb, long long int strideB,
const cuComplex *beta, /* host or device pointer */
cuComplex *C, int ldc, long long int strideC, int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuComplex *, const cuComplex *, int, long long, const cuComplex *,
int, long long, const cuComplex *, cuComplex *, int, long long, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm3mStridedBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, strideA, B,
ldb, strideB, beta, C, ldc, strideC, batchCount);
}
cublasStatus_t CUBLASWINAPI cublasZgemmStridedBatched(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, int k,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda,
long long int strideA, /* purposely signed */
const cuDoubleComplex *B, int ldb, long long int strideB,
const cuDoubleComplex *beta, /* host or device poi */
cuDoubleComplex *C, int ldc, long long int strideC, int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int, long long,
const cuDoubleComplex *, int, long long, const cuDoubleComplex *,
cuDoubleComplex *, int, long long, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemmStridedBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, strideA, B,
ldb, strideB, beta, C, ldc, strideC, batchCount);
}
cublasStatus_t CUBLASWINAPI cublasSgeam(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, const float *alpha, /* host or device pointer */
const float *A, int lda, const float *beta, /* host or device pointer */
const float *B, int ldb, float *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int,
const float *, const float *, int, const float *, const float *, int,
float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgeam");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, alpha, A, lda, beta, B, ldb, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasDgeam(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, const double *alpha, /* host or device pointer */
const double *A, int lda, const double *beta, /* host or device pointer */
const double *B, int ldb, double *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int,
const double *, const double *, int, const double *, const double *, int,
double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgeam");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, alpha, A, lda, beta, B, ldb, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasCgeam(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, const cuComplex *alpha, /* host or device pointer */
const cuComplex *A, int lda,
const cuComplex *beta, /* host or device pointer */
const cuComplex *B, int ldb, cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int,
const cuComplex *, const cuComplex *, int, const cuComplex *,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgeam");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, alpha, A, lda, beta, B, ldb, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasZgeam(
cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb,
int m, int n, const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A, int lda,
const cuDoubleComplex *beta, /* host or device pointer */
const cuDoubleComplex *B, int ldb, cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int,
const cuDoubleComplex *, const cuDoubleComplex *, int,
const cuDoubleComplex *, const cuDoubleComplex *, int, cuDoubleComplex *,
int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgeam");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, transa, transb, m, n, alpha, A, lda, beta, B, ldb, C,
ldc);
}
cublasStatus_t CUBLASWINAPI cublasSgetrfBatched(
cublasHandle_t handle, int n, float *const A[], /*Device pointer*/
int lda, int *P, /*Device Pointer*/
int *info, /*Device Pointer*/
int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, float *const[], int, int *, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgetrfBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, P, info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasDgetrfBatched(
cublasHandle_t handle, int n, double *const A[], /*Device pointer*/
int lda, int *P, /*Device Pointer*/
int *info, /*Device Pointer*/
int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, double *const[], int, int *, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgetrfBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, P, info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasCgetrfBatched(
cublasHandle_t handle, int n, cuComplex *const A[], /*Device pointer*/
int lda, int *P, /*Device Pointer*/
int *info, /*Device Pointer*/
int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, cuComplex *const[], int, int *, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgetrfBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, P, info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasZgetrfBatched(
cublasHandle_t handle, int n, cuDoubleComplex *const A[], /*Device pointer*/
int lda, int *P, /*Device Pointer*/
int *info, /*Device Pointer*/
int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, cuDoubleComplex *const[], int, int *, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgetrfBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, P, info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasSgetriBatched(
cublasHandle_t handle, int n, const float *const A[], /*Device pointer*/
int lda, const int *P, /*Device pointer*/
float *const C[], /*Device pointer*/
int ldc, int *info, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const float *const[], int, const int *,
float *const[], int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgetriBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, P, C, ldc, info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasDgetriBatched(
cublasHandle_t handle, int n, const double *const A[], /*Device pointer*/
int lda, const int *P, /*Device pointer*/
double *const C[], /*Device pointer*/
int ldc, int *info, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const double *const[], int, const int *,
double *const[], int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgetriBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, P, C, ldc, info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasCgetriBatched(
cublasHandle_t handle, int n, const cuComplex *const A[], /*Device pointer*/
int lda, const int *P, /*Device pointer*/
cuComplex *const C[], /*Device pointer*/
int ldc, int *info, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuComplex *const[], int, const int *,
cuComplex *const[], int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgetriBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, P, C, ldc, info, batchSize);
}
cublasStatus_t CUBLASWINAPI
cublasZgetriBatched(cublasHandle_t handle, int n,
const cuDoubleComplex *const A[], /*Device pointer*/
int lda, const int *P, /*Device pointer*/
cuDoubleComplex *const C[], /*Device pointer*/
int ldc, int *info, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuDoubleComplex *const[], int, const int *,
cuDoubleComplex *const[], int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgetriBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, P, C, ldc, info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasSgetrsBatched(
cublasHandle_t handle, cublasOperation_t trans, int n, int nrhs,
const float *const Aarray[], int lda, const int *devIpiv,
float *const Barray[], int ldb, int *info, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, const float *const[], int,
const int *, float *const[], int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgetrsBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, n, nrhs, Aarray, lda, devIpiv, Barray, ldb,
info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasDgetrsBatched(
cublasHandle_t handle, cublasOperation_t trans, int n, int nrhs,
const double *const Aarray[], int lda, const int *devIpiv,
double *const Barray[], int ldb, int *info, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, const double *const[], int,
const int *, double *const[], int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgetrsBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, n, nrhs, Aarray, lda, devIpiv, Barray, ldb,
info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasCgetrsBatched(
cublasHandle_t handle, cublasOperation_t trans, int n, int nrhs,
const cuComplex *const Aarray[], int lda, const int *devIpiv,
cuComplex *const Barray[], int ldb, int *info, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, const cuComplex *const[],
int, const int *, cuComplex *const[], int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgetrsBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, n, nrhs, Aarray, lda, devIpiv, Barray, ldb,
info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasZgetrsBatched(
cublasHandle_t handle, cublasOperation_t trans, int n, int nrhs,
const cuDoubleComplex *const Aarray[], int lda, const int *devIpiv,
cuDoubleComplex *const Barray[], int ldb, int *info, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int,
const cuDoubleComplex *const[], int, const int *,
cuDoubleComplex *const[], int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgetrsBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, n, nrhs, Aarray, lda, devIpiv, Barray, ldb,
info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasStrsmBatched(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const float *alpha, /*Host or Device Pointer*/
const float *const A[], int lda, float *const B[], int ldb,
int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const float *, const float *const[], int,
float *const[], int, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrsmBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb,
batchCount);
}
cublasStatus_t CUBLASWINAPI cublasDtrsmBatched(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const double *alpha, /*Host or Device Pointer*/
const double *const A[], int lda, double *const B[], int ldb,
int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const double *, const double *const[], int,
double *const[], int, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrsmBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb,
batchCount);
}
cublasStatus_t CUBLASWINAPI cublasCtrsmBatched(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const cuComplex *alpha, /*Host or Device Pointer*/
const cuComplex *const A[], int lda, cuComplex *const B[], int ldb,
int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const cuComplex *, const cuComplex *const[],
int, cuComplex *const[], int, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrsmBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb,
batchCount);
}
cublasStatus_t CUBLASWINAPI cublasZtrsmBatched(
cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
cublasOperation_t trans, cublasDiagType_t diag, int m, int n,
const cuDoubleComplex *alpha, /*Host or Device Pointer*/
const cuDoubleComplex *const A[], int lda, cuDoubleComplex *const B[],
int ldb, int batchCount) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
cublasDiagType_t, int, int, const cuDoubleComplex *,
const cuDoubleComplex *const[], int, cuDoubleComplex *const[], int, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrsmBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb,
batchCount);
}
cublasStatus_t CUBLASWINAPI cublasSmatinvBatched(
cublasHandle_t handle, int n, const float *const A[], /*Device pointer*/
int lda, float *const Ainv[], /*Device pointer*/
int lda_inv, int *info, /*Device Pointer*/
int batchSize) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, const float *const[],
int, float *const[], int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSmatinvBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, Ainv, lda_inv, info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasDmatinvBatched(
cublasHandle_t handle, int n, const double *const A[], /*Device pointer*/
int lda, double *const Ainv[], /*Device pointer*/
int lda_inv, int *info, /*Device Pointer*/
int batchSize) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, const double *const[],
int, double *const[], int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDmatinvBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, Ainv, lda_inv, info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasCmatinvBatched(
cublasHandle_t handle, int n, const cuComplex *const A[], /*Device pointer*/
int lda, cuComplex *const Ainv[], /*Device pointer*/
int lda_inv, int *info, /*Device Pointer*/
int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuComplex *const[], int, cuComplex *const[],
int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCmatinvBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, Ainv, lda_inv, info, batchSize);
}
cublasStatus_t CUBLASWINAPI
cublasZmatinvBatched(cublasHandle_t handle, int n,
const cuDoubleComplex *const A[], /*Device pointer*/
int lda, cuDoubleComplex *const Ainv[], /*Device pointer*/
int lda_inv, int *info, /*Device Pointer*/
int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, const cuDoubleComplex *const[], int,
cuDoubleComplex *const[], int, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZmatinvBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, n, A, lda, Ainv, lda_inv, info, batchSize);
}
cublasStatus_t CUBLASWINAPI
cublasSgeqrfBatched(cublasHandle_t handle, int m, int n,
float *const Aarray[], /*Device pointer*/
int lda, float *const TauArray[], /*Device pointer*/
int *info, int batchSize) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, int, float *const[],
int, float *const[], int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgeqrfBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, m, n, Aarray, lda, TauArray, info, batchSize);
}
cublasStatus_t CUBLASWINAPI
cublasDgeqrfBatched(cublasHandle_t handle, int m, int n,
double *const Aarray[], /*Device pointer*/
int lda, double *const TauArray[], /*Device pointer*/
int *info, int batchSize) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, int, double *const[],
int, double *const[], int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgeqrfBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, m, n, Aarray, lda, TauArray, info, batchSize);
}
cublasStatus_t CUBLASWINAPI
cublasCgeqrfBatched(cublasHandle_t handle, int m, int n,
cuComplex *const Aarray[], /*Device pointer*/
int lda, cuComplex *const TauArray[], /*Device pointer*/
int *info, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, int, cuComplex *const[], int, cuComplex *const[],
int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgeqrfBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, m, n, Aarray, lda, TauArray, info, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasZgeqrfBatched(
cublasHandle_t handle, int m, int n,
cuDoubleComplex *const Aarray[], /*Device pointer*/
int lda, cuDoubleComplex *const TauArray[], /*Device pointer*/
int *info, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, int, int, cuDoubleComplex *const[], int,
cuDoubleComplex *const[], int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgeqrfBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, m, n, Aarray, lda, TauArray, info, batchSize);
}
cublasStatus_t CUBLASWINAPI
cublasSgelsBatched(cublasHandle_t handle, cublasOperation_t trans, int m, int n,
int nrhs, float *const Aarray[], /*Device pointer*/
int lda, float *const Carray[], /*Device pointer*/
int ldc, int *info, int *devInfoArray, /*Device pointer*/
int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, int, float *const[], int,
float *const[], int, int *, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgelsBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info,
devInfoArray, batchSize);
}
cublasStatus_t CUBLASWINAPI
cublasDgelsBatched(cublasHandle_t handle, cublasOperation_t trans, int m, int n,
int nrhs, double *const Aarray[], /*Device pointer*/
int lda, double *const Carray[], /*Device pointer*/
int ldc, int *info, int *devInfoArray, /*Device pointer*/
int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, int, double *const[], int,
double *const[], int, int *, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgelsBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info,
devInfoArray, batchSize);
}
cublasStatus_t CUBLASWINAPI
cublasCgelsBatched(cublasHandle_t handle, cublasOperation_t trans, int m, int n,
int nrhs, cuComplex *const Aarray[], /*Device pointer*/
int lda, cuComplex *const Carray[], /*Device pointer*/
int ldc, int *info, int *devInfoArray, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, int, cuComplex *const[], int,
cuComplex *const[], int, int *, int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgelsBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info,
devInfoArray, batchSize);
}
cublasStatus_t CUBLASWINAPI
cublasZgelsBatched(cublasHandle_t handle, cublasOperation_t trans, int m, int n,
int nrhs, cuDoubleComplex *const Aarray[], /*Device pointer*/
int lda, cuDoubleComplex *const Carray[], /*Device pointer*/
int ldc, int *info, int *devInfoArray, int batchSize) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasOperation_t, int, int, int,
cuDoubleComplex *const[], int, cuDoubleComplex *const[], int, int *,
int *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgelsBatched");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info,
devInfoArray, batchSize);
}
cublasStatus_t CUBLASWINAPI cublasSdgmm(cublasHandle_t handle,
cublasSideMode_t mode, int m, int n,
const float *A, int lda, const float *x,
int incx, float *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, int, int, const float *, int,
const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSdgmm");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, mode, m, n, A, lda, x, incx, C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasDdgmm(cublasHandle_t handle,
cublasSideMode_t mode, int m, int n,
const double *A, int lda,
const double *x, int incx, double *C,
int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, int, int, const double *, int,
const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDdgmm");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, mode, m, n, A, lda, x, incx, C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasCdgmm(cublasHandle_t handle,
cublasSideMode_t mode, int m, int n,
const cuComplex *A, int lda,
const cuComplex *x, int incx,
cuComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, int, int, const cuComplex *, int,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCdgmm");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, mode, m, n, A, lda, x, incx, C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasZdgmm(cublasHandle_t handle,
cublasSideMode_t mode, int m, int n,
const cuDoubleComplex *A, int lda,
const cuDoubleComplex *x, int incx,
cuDoubleComplex *C, int ldc) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasSideMode_t, int, int, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdgmm");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, mode, m, n, A, lda, x, incx, C, ldc);
}
cublasStatus_t CUBLASWINAPI cublasStpttr(cublasHandle_t handle,
cublasFillMode_t uplo, int n,
const float *AP, float *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStpttr");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, AP, A, lda);
}
cublasStatus_t CUBLASWINAPI cublasDtpttr(cublasHandle_t handle,
cublasFillMode_t uplo, int n,
const double *AP, double *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const double *, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtpttr");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, AP, A, lda);
}
cublasStatus_t CUBLASWINAPI cublasCtpttr(cublasHandle_t handle,
cublasFillMode_t uplo, int n,
const cuComplex *AP, cuComplex *A,
int lda) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasFillMode_t, int,
const cuComplex *, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtpttr");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, AP, A, lda);
}
cublasStatus_t CUBLASWINAPI cublasZtpttr(cublasHandle_t handle,
cublasFillMode_t uplo, int n,
const cuDoubleComplex *AP,
cuDoubleComplex *A, int lda) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtpttr");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, AP, A, lda);
}
cublasStatus_t CUBLASWINAPI cublasStrttp(cublasHandle_t handle,
cublasFillMode_t uplo, int n,
const float *A, int lda, float *AP) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const float *, int, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrttp");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, A, lda, AP);
}
cublasStatus_t CUBLASWINAPI cublasDtrttp(cublasHandle_t handle,
cublasFillMode_t uplo, int n,
const double *A, int lda, double *AP) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const double *, int, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrttp");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, A, lda, AP);
}
cublasStatus_t CUBLASWINAPI cublasCtrttp(cublasHandle_t handle,
cublasFillMode_t uplo, int n,
const cuComplex *A, int lda,
cuComplex *AP) {
using FuncPtr =
cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasFillMode_t, int,
const cuComplex *, int, cuComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrttp");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, A, lda, AP);
}
cublasStatus_t CUBLASWINAPI cublasZtrttp(cublasHandle_t handle,
cublasFillMode_t uplo, int n,
const cuDoubleComplex *A, int lda,
cuDoubleComplex *AP) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(
cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, int,
cuDoubleComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrttp");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(handle, uplo, n, A, lda, AP);
}
cublasStatus CUBLASWINAPI cublasInit(void) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)();
static auto func_ptr = LoadSymbol<FuncPtr>("cublasInit");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr();
}
cublasStatus CUBLASWINAPI cublasShutdown(void) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)();
static auto func_ptr = LoadSymbol<FuncPtr>("cublasShutdown");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr();
}
cublasStatus CUBLASWINAPI cublasGetError(void) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)();
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetError");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr();
}
cublasStatus CUBLASWINAPI cublasGetVersion(int *version) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetVersion");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(version);
}
cublasStatus CUBLASWINAPI cublasAlloc(int n, int elemSize, void **devicePtr) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, void **);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasAlloc");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(n, elemSize, devicePtr);
}
cublasStatus CUBLASWINAPI cublasFree(void *devicePtr) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(void *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasFree");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(devicePtr);
}
cublasStatus CUBLASWINAPI cublasSetKernelStream(cudaStream_t stream) {
using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cudaStream_t);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetKernelStream");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(stream);
}
float CUBLASWINAPI cublasSnrm2(int n, const float *x, int incx) {
using FuncPtr = float(CUBLASWINAPI *)(int, const float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSnrm2");
if (!func_ptr) LogFatalSymbolNotFound("cublasSnrm2");
return func_ptr(n, x, incx);
}
double CUBLASWINAPI cublasDnrm2(int n, const double *x, int incx) {
using FuncPtr = double(CUBLASWINAPI *)(int, const double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDnrm2");
if (!func_ptr) LogFatalSymbolNotFound("cublasDnrm2");
return func_ptr(n, x, incx);
}
float CUBLASWINAPI cublasScnrm2(int n, const cuComplex *x, int incx) {
using FuncPtr = float(CUBLASWINAPI *)(int, const cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasScnrm2");
if (!func_ptr) LogFatalSymbolNotFound("cublasScnrm2");
return func_ptr(n, x, incx);
}
double CUBLASWINAPI cublasDznrm2(int n, const cuDoubleComplex *x, int incx) {
using FuncPtr = double(CUBLASWINAPI *)(int, const cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDznrm2");
if (!func_ptr) LogFatalSymbolNotFound("cublasDznrm2");
return func_ptr(n, x, incx);
}
float CUBLASWINAPI cublasSdot(int n, const float *x, int incx, const float *y,
int incy) {
using FuncPtr =
float(CUBLASWINAPI *)(int, const float *, int, const float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSdot");
if (!func_ptr) LogFatalSymbolNotFound("cublasSdot");
return func_ptr(n, x, incx, y, incy);
}
double CUBLASWINAPI cublasDdot(int n, const double *x, int incx,
const double *y, int incy) {
using FuncPtr =
double(CUBLASWINAPI *)(int, const double *, int, const double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDdot");
if (!func_ptr) LogFatalSymbolNotFound("cublasDdot");
return func_ptr(n, x, incx, y, incy);
}
cuComplex CUBLASWINAPI cublasCdotu(int n, const cuComplex *x, int incx,
const cuComplex *y, int incy) {
using FuncPtr = cuComplex(CUBLASWINAPI *)(int, const cuComplex *, int,
const cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCdotu");
if (!func_ptr) LogFatalSymbolNotFound("cublasCdotu");
return func_ptr(n, x, incx, y, incy);
}
cuComplex CUBLASWINAPI cublasCdotc(int n, const cuComplex *x, int incx,
const cuComplex *y, int incy) {
using FuncPtr = cuComplex(CUBLASWINAPI *)(int, const cuComplex *, int,
const cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCdotc");
if (!func_ptr) LogFatalSymbolNotFound("cublasCdotc");
return func_ptr(n, x, incx, y, incy);
}
cuDoubleComplex CUBLASWINAPI cublasZdotu(int n, const cuDoubleComplex *x,
int incx, const cuDoubleComplex *y,
int incy) {
using FuncPtr = cuDoubleComplex(CUBLASWINAPI *)(
int, const cuDoubleComplex *, int, const cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdotu");
if (!func_ptr) LogFatalSymbolNotFound("cublasZdotu");
return func_ptr(n, x, incx, y, incy);
}
cuDoubleComplex CUBLASWINAPI cublasZdotc(int n, const cuDoubleComplex *x,
int incx, const cuDoubleComplex *y,
int incy) {
using FuncPtr = cuDoubleComplex(CUBLASWINAPI *)(
int, const cuDoubleComplex *, int, const cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdotc");
if (!func_ptr) LogFatalSymbolNotFound("cublasZdotc");
return func_ptr(n, x, incx, y, incy);
}
void CUBLASWINAPI cublasSscal(int n, float alpha, float *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(int, float, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSscal");
if (!func_ptr) LogFatalSymbolNotFound("cublasSscal");
return func_ptr(n, alpha, x, incx);
}
void CUBLASWINAPI cublasDscal(int n, double alpha, double *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(int, double, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDscal");
if (!func_ptr) LogFatalSymbolNotFound("cublasDscal");
return func_ptr(n, alpha, x, incx);
}
void CUBLASWINAPI cublasCscal(int n, cuComplex alpha, cuComplex *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(int, cuComplex, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCscal");
if (!func_ptr) LogFatalSymbolNotFound("cublasCscal");
return func_ptr(n, alpha, x, incx);
}
void CUBLASWINAPI cublasZscal(int n, cuDoubleComplex alpha, cuDoubleComplex *x,
int incx) {
using FuncPtr =
void(CUBLASWINAPI *)(int, cuDoubleComplex, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZscal");
if (!func_ptr) LogFatalSymbolNotFound("cublasZscal");
return func_ptr(n, alpha, x, incx);
}
void CUBLASWINAPI cublasCsscal(int n, float alpha, cuComplex *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(int, float, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsscal");
if (!func_ptr) LogFatalSymbolNotFound("cublasCsscal");
return func_ptr(n, alpha, x, incx);
}
void CUBLASWINAPI cublasZdscal(int n, double alpha, cuDoubleComplex *x,
int incx) {
using FuncPtr = void(CUBLASWINAPI *)(int, double, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdscal");
if (!func_ptr) LogFatalSymbolNotFound("cublasZdscal");
return func_ptr(n, alpha, x, incx);
}
void CUBLASWINAPI cublasSaxpy(int n, float alpha, const float *x, int incx,
float *y, int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(int, float, const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSaxpy");
if (!func_ptr) LogFatalSymbolNotFound("cublasSaxpy");
return func_ptr(n, alpha, x, incx, y, incy);
}
void CUBLASWINAPI cublasDaxpy(int n, double alpha, const double *x, int incx,
double *y, int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(int, double, const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDaxpy");
if (!func_ptr) LogFatalSymbolNotFound("cublasDaxpy");
return func_ptr(n, alpha, x, incx, y, incy);
}
void CUBLASWINAPI cublasCaxpy(int n, cuComplex alpha, const cuComplex *x,
int incx, cuComplex *y, int incy) {
using FuncPtr = void(CUBLASWINAPI *)(int, cuComplex, const cuComplex *, int,
cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCaxpy");
if (!func_ptr) LogFatalSymbolNotFound("cublasCaxpy");
return func_ptr(n, alpha, x, incx, y, incy);
}
void CUBLASWINAPI cublasZaxpy(int n, cuDoubleComplex alpha,
const cuDoubleComplex *x, int incx,
cuDoubleComplex *y, int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(int, cuDoubleComplex, const cuDoubleComplex *, int,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZaxpy");
if (!func_ptr) LogFatalSymbolNotFound("cublasZaxpy");
return func_ptr(n, alpha, x, incx, y, incy);
}
void CUBLASWINAPI cublasScopy(int n, const float *x, int incx, float *y,
int incy) {
using FuncPtr = void(CUBLASWINAPI *)(int, const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasScopy");
if (!func_ptr) LogFatalSymbolNotFound("cublasScopy");
return func_ptr(n, x, incx, y, incy);
}
void CUBLASWINAPI cublasDcopy(int n, const double *x, int incx, double *y,
int incy) {
using FuncPtr = void(CUBLASWINAPI *)(int, const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDcopy");
if (!func_ptr) LogFatalSymbolNotFound("cublasDcopy");
return func_ptr(n, x, incx, y, incy);
}
void CUBLASWINAPI cublasCcopy(int n, const cuComplex *x, int incx, cuComplex *y,
int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(int, const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCcopy");
if (!func_ptr) LogFatalSymbolNotFound("cublasCcopy");
return func_ptr(n, x, incx, y, incy);
}
void CUBLASWINAPI cublasZcopy(int n, const cuDoubleComplex *x, int incx,
cuDoubleComplex *y, int incy) {
using FuncPtr = void(CUBLASWINAPI *)(int, const cuDoubleComplex *, int,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZcopy");
if (!func_ptr) LogFatalSymbolNotFound("cublasZcopy");
return func_ptr(n, x, incx, y, incy);
}
void CUBLASWINAPI cublasSswap(int n, float *x, int incx, float *y, int incy) {
using FuncPtr = void(CUBLASWINAPI *)(int, float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSswap");
if (!func_ptr) LogFatalSymbolNotFound("cublasSswap");
return func_ptr(n, x, incx, y, incy);
}
void CUBLASWINAPI cublasDswap(int n, double *x, int incx, double *y, int incy) {
using FuncPtr = void(CUBLASWINAPI *)(int, double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDswap");
if (!func_ptr) LogFatalSymbolNotFound("cublasDswap");
return func_ptr(n, x, incx, y, incy);
}
void CUBLASWINAPI cublasCswap(int n, cuComplex *x, int incx, cuComplex *y,
int incy) {
using FuncPtr = void(CUBLASWINAPI *)(int, cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCswap");
if (!func_ptr) LogFatalSymbolNotFound("cublasCswap");
return func_ptr(n, x, incx, y, incy);
}
void CUBLASWINAPI cublasZswap(int n, cuDoubleComplex *x, int incx,
cuDoubleComplex *y, int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(int, cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZswap");
if (!func_ptr) LogFatalSymbolNotFound("cublasZswap");
return func_ptr(n, x, incx, y, incy);
}
int CUBLASWINAPI cublasIsamax(int n, const float *x, int incx) {
using FuncPtr = int(CUBLASWINAPI *)(int, const float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIsamax");
if (!func_ptr) LogFatalSymbolNotFound("cublasIsamax");
return func_ptr(n, x, incx);
}
int CUBLASWINAPI cublasIdamax(int n, const double *x, int incx) {
using FuncPtr = int(CUBLASWINAPI *)(int, const double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIdamax");
if (!func_ptr) LogFatalSymbolNotFound("cublasIdamax");
return func_ptr(n, x, incx);
}
int CUBLASWINAPI cublasIcamax(int n, const cuComplex *x, int incx) {
using FuncPtr = int(CUBLASWINAPI *)(int, const cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIcamax");
if (!func_ptr) LogFatalSymbolNotFound("cublasIcamax");
return func_ptr(n, x, incx);
}
int CUBLASWINAPI cublasIzamax(int n, const cuDoubleComplex *x, int incx) {
using FuncPtr = int(CUBLASWINAPI *)(int, const cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIzamax");
if (!func_ptr) LogFatalSymbolNotFound("cublasIzamax");
return func_ptr(n, x, incx);
}
int CUBLASWINAPI cublasIsamin(int n, const float *x, int incx) {
using FuncPtr = int(CUBLASWINAPI *)(int, const float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIsamin");
if (!func_ptr) LogFatalSymbolNotFound("cublasIsamin");
return func_ptr(n, x, incx);
}
int CUBLASWINAPI cublasIdamin(int n, const double *x, int incx) {
using FuncPtr = int(CUBLASWINAPI *)(int, const double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIdamin");
if (!func_ptr) LogFatalSymbolNotFound("cublasIdamin");
return func_ptr(n, x, incx);
}
int CUBLASWINAPI cublasIcamin(int n, const cuComplex *x, int incx) {
using FuncPtr = int(CUBLASWINAPI *)(int, const cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIcamin");
if (!func_ptr) LogFatalSymbolNotFound("cublasIcamin");
return func_ptr(n, x, incx);
}
int CUBLASWINAPI cublasIzamin(int n, const cuDoubleComplex *x, int incx) {
using FuncPtr = int(CUBLASWINAPI *)(int, const cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasIzamin");
if (!func_ptr) LogFatalSymbolNotFound("cublasIzamin");
return func_ptr(n, x, incx);
}
float CUBLASWINAPI cublasSasum(int n, const float *x, int incx) {
using FuncPtr = float(CUBLASWINAPI *)(int, const float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSasum");
if (!func_ptr) LogFatalSymbolNotFound("cublasSasum");
return func_ptr(n, x, incx);
}
double CUBLASWINAPI cublasDasum(int n, const double *x, int incx) {
using FuncPtr = double(CUBLASWINAPI *)(int, const double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDasum");
if (!func_ptr) LogFatalSymbolNotFound("cublasDasum");
return func_ptr(n, x, incx);
}
float CUBLASWINAPI cublasScasum(int n, const cuComplex *x, int incx) {
using FuncPtr = float(CUBLASWINAPI *)(int, const cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasScasum");
if (!func_ptr) LogFatalSymbolNotFound("cublasScasum");
return func_ptr(n, x, incx);
}
double CUBLASWINAPI cublasDzasum(int n, const cuDoubleComplex *x, int incx) {
using FuncPtr = double(CUBLASWINAPI *)(int, const cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDzasum");
if (!func_ptr) LogFatalSymbolNotFound("cublasDzasum");
return func_ptr(n, x, incx);
}
void CUBLASWINAPI cublasSrot(int n, float *x, int incx, float *y, int incy,
float sc, float ss) {
using FuncPtr =
void(CUBLASWINAPI *)(int, float *, int, float *, int, float, float);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrot");
if (!func_ptr) LogFatalSymbolNotFound("cublasSrot");
return func_ptr(n, x, incx, y, incy, sc, ss);
}
void CUBLASWINAPI cublasDrot(int n, double *x, int incx, double *y, int incy,
double sc, double ss) {
using FuncPtr =
void(CUBLASWINAPI *)(int, double *, int, double *, int, double, double);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrot");
if (!func_ptr) LogFatalSymbolNotFound("cublasDrot");
return func_ptr(n, x, incx, y, incy, sc, ss);
}
void CUBLASWINAPI cublasCrot(int n, cuComplex *x, int incx, cuComplex *y,
int incy, float c, cuComplex s) {
using FuncPtr = void(CUBLASWINAPI *)(int, cuComplex *, int, cuComplex *, int,
float, cuComplex);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCrot");
if (!func_ptr) LogFatalSymbolNotFound("cublasCrot");
return func_ptr(n, x, incx, y, incy, c, s);
}
void CUBLASWINAPI cublasZrot(int n, cuDoubleComplex *x, int incx,
cuDoubleComplex *y, int incy, double sc,
cuDoubleComplex cs) {
using FuncPtr =
void(CUBLASWINAPI *)(int, cuDoubleComplex *, int, cuDoubleComplex *, int,
double, cuDoubleComplex);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZrot");
if (!func_ptr) LogFatalSymbolNotFound("cublasZrot");
return func_ptr(n, x, incx, y, incy, sc, cs);
}
void CUBLASWINAPI cublasCsrot(int n, cuComplex *x, int incx, cuComplex *y,
int incy, float c, float s) {
using FuncPtr = void(CUBLASWINAPI *)(int, cuComplex *, int, cuComplex *, int,
float, float);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsrot");
if (!func_ptr) LogFatalSymbolNotFound("cublasCsrot");
return func_ptr(n, x, incx, y, incy, c, s);
}
void CUBLASWINAPI cublasZdrot(int n, cuDoubleComplex *x, int incx,
cuDoubleComplex *y, int incy, double c,
double s) {
using FuncPtr = void(CUBLASWINAPI *)(int, cuDoubleComplex *, int,
cuDoubleComplex *, int, double, double);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdrot");
if (!func_ptr) LogFatalSymbolNotFound("cublasZdrot");
return func_ptr(n, x, incx, y, incy, c, s);
}
void CUBLASWINAPI cublasSrotg(float *sa, float *sb, float *sc, float *ss) {
using FuncPtr = void(CUBLASWINAPI *)(float *, float *, float *, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotg");
if (!func_ptr) LogFatalSymbolNotFound("cublasSrotg");
return func_ptr(sa, sb, sc, ss);
}
void CUBLASWINAPI cublasDrotg(double *sa, double *sb, double *sc, double *ss) {
using FuncPtr = void(CUBLASWINAPI *)(double *, double *, double *, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotg");
if (!func_ptr) LogFatalSymbolNotFound("cublasDrotg");
return func_ptr(sa, sb, sc, ss);
}
void CUBLASWINAPI cublasCrotg(cuComplex *ca, cuComplex cb, float *sc,
cuComplex *cs) {
using FuncPtr =
void(CUBLASWINAPI *)(cuComplex *, cuComplex, float *, cuComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCrotg");
if (!func_ptr) LogFatalSymbolNotFound("cublasCrotg");
return func_ptr(ca, cb, sc, cs);
}
void CUBLASWINAPI cublasZrotg(cuDoubleComplex *ca, cuDoubleComplex cb,
double *sc, cuDoubleComplex *cs) {
using FuncPtr = void(CUBLASWINAPI *)(cuDoubleComplex *, cuDoubleComplex,
double *, cuDoubleComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZrotg");
if (!func_ptr) LogFatalSymbolNotFound("cublasZrotg");
return func_ptr(ca, cb, sc, cs);
}
void CUBLASWINAPI cublasSrotm(int n, float *x, int incx, float *y, int incy,
const float *sparam) {
using FuncPtr =
void(CUBLASWINAPI *)(int, float *, int, float *, int, const float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotm");
if (!func_ptr) LogFatalSymbolNotFound("cublasSrotm");
return func_ptr(n, x, incx, y, incy, sparam);
}
void CUBLASWINAPI cublasDrotm(int n, double *x, int incx, double *y, int incy,
const double *sparam) {
using FuncPtr =
void(CUBLASWINAPI *)(int, double *, int, double *, int, const double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotm");
if (!func_ptr) LogFatalSymbolNotFound("cublasDrotm");
return func_ptr(n, x, incx, y, incy, sparam);
}
void CUBLASWINAPI cublasSrotmg(float *sd1, float *sd2, float *sx1,
const float *sy1, float *sparam) {
using FuncPtr =
void(CUBLASWINAPI *)(float *, float *, float *, const float *, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotmg");
if (!func_ptr) LogFatalSymbolNotFound("cublasSrotmg");
return func_ptr(sd1, sd2, sx1, sy1, sparam);
}
void CUBLASWINAPI cublasDrotmg(double *sd1, double *sd2, double *sx1,
const double *sy1, double *sparam) {
using FuncPtr = void(CUBLASWINAPI *)(double *, double *, double *,
const double *, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotmg");
if (!func_ptr) LogFatalSymbolNotFound("cublasDrotmg");
return func_ptr(sd1, sd2, sx1, sy1, sparam);
}
void CUBLASWINAPI cublasSgemv(char trans, int m, int n, float alpha,
const float *A, int lda, const float *x, int incx,
float beta, float *y, int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, int, float, const float *, int,
const float *, int, float, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemv");
if (!func_ptr) LogFatalSymbolNotFound("cublasSgemv");
return func_ptr(trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasDgemv(char trans, int m, int n, double alpha,
const double *A, int lda, const double *x,
int incx, double beta, double *y, int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, int, double, const double *, int,
const double *, int, double, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemv");
if (!func_ptr) LogFatalSymbolNotFound("cublasDgemv");
return func_ptr(trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasCgemv(char trans, int m, int n, cuComplex alpha,
const cuComplex *A, int lda, const cuComplex *x,
int incx, cuComplex beta, cuComplex *y,
int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemv");
if (!func_ptr) LogFatalSymbolNotFound("cublasCgemv");
return func_ptr(trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasZgemv(char trans, int m, int n, cuDoubleComplex alpha,
const cuDoubleComplex *A, int lda,
const cuDoubleComplex *x, int incx,
cuDoubleComplex beta, cuDoubleComplex *y,
int incy) {
using FuncPtr = void(CUBLASWINAPI *)(
char, int, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemv");
if (!func_ptr) LogFatalSymbolNotFound("cublasZgemv");
return func_ptr(trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasSgbmv(char trans, int m, int n, int kl, int ku,
float alpha, const float *A, int lda,
const float *x, int incx, float beta, float *y,
int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, int, int, int, float, const float *, int,
const float *, int, float, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasSgbmv");
return func_ptr(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasDgbmv(char trans, int m, int n, int kl, int ku,
double alpha, const double *A, int lda,
const double *x, int incx, double beta, double *y,
int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, int, int, int, double, const double *,
int, const double *, int, double, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasDgbmv");
return func_ptr(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasCgbmv(char trans, int m, int n, int kl, int ku,
cuComplex alpha, const cuComplex *A, int lda,
const cuComplex *x, int incx, cuComplex beta,
cuComplex *y, int incy) {
using FuncPtr = void(CUBLASWINAPI *)(
char, int, int, int, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasCgbmv");
return func_ptr(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasZgbmv(char trans, int m, int n, int kl, int ku,
cuDoubleComplex alpha, const cuDoubleComplex *A,
int lda, const cuDoubleComplex *x, int incx,
cuDoubleComplex beta, cuDoubleComplex *y,
int incy) {
using FuncPtr = void(CUBLASWINAPI *)(
char, int, int, int, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasZgbmv");
return func_ptr(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasStrmv(char uplo, char trans, char diag, int n,
const float *A, int lda, float *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const float *,
int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasStrmv");
return func_ptr(uplo, trans, diag, n, A, lda, x, incx);
}
void CUBLASWINAPI cublasDtrmv(char uplo, char trans, char diag, int n,
const double *A, int lda, double *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const double *,
int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasDtrmv");
return func_ptr(uplo, trans, diag, n, A, lda, x, incx);
}
void CUBLASWINAPI cublasCtrmv(char uplo, char trans, char diag, int n,
const cuComplex *A, int lda, cuComplex *x,
int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const cuComplex *,
int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasCtrmv");
return func_ptr(uplo, trans, diag, n, A, lda, x, incx);
}
void CUBLASWINAPI cublasZtrmv(char uplo, char trans, char diag, int n,
const cuDoubleComplex *A, int lda,
cuDoubleComplex *x, int incx) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, char, int, const cuDoubleComplex *, int,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasZtrmv");
return func_ptr(uplo, trans, diag, n, A, lda, x, incx);
}
void CUBLASWINAPI cublasStbmv(char uplo, char trans, char diag, int n, int k,
const float *A, int lda, float *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, int,
const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasStbmv");
return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx);
}
void CUBLASWINAPI cublasDtbmv(char uplo, char trans, char diag, int n, int k,
const double *A, int lda, double *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, int,
const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasDtbmv");
return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx);
}
void CUBLASWINAPI cublasCtbmv(char uplo, char trans, char diag, int n, int k,
const cuComplex *A, int lda, cuComplex *x,
int incx) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, char, int, int, const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasCtbmv");
return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx);
}
void CUBLASWINAPI cublasZtbmv(char uplo, char trans, char diag, int n, int k,
const cuDoubleComplex *A, int lda,
cuDoubleComplex *x, int incx) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, char, int, int, const cuDoubleComplex *,
int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasZtbmv");
return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx);
}
void CUBLASWINAPI cublasStpmv(char uplo, char trans, char diag, int n,
const float *AP, float *x, int incx) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, char, int, const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStpmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasStpmv");
return func_ptr(uplo, trans, diag, n, AP, x, incx);
}
void CUBLASWINAPI cublasDtpmv(char uplo, char trans, char diag, int n,
const double *AP, double *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const double *,
double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtpmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasDtpmv");
return func_ptr(uplo, trans, diag, n, AP, x, incx);
}
void CUBLASWINAPI cublasCtpmv(char uplo, char trans, char diag, int n,
const cuComplex *AP, cuComplex *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const cuComplex *,
cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtpmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasCtpmv");
return func_ptr(uplo, trans, diag, n, AP, x, incx);
}
void CUBLASWINAPI cublasZtpmv(char uplo, char trans, char diag, int n,
const cuDoubleComplex *AP, cuDoubleComplex *x,
int incx) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, char, int, const cuDoubleComplex *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtpmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasZtpmv");
return func_ptr(uplo, trans, diag, n, AP, x, incx);
}
void CUBLASWINAPI cublasStrsv(char uplo, char trans, char diag, int n,
const float *A, int lda, float *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const float *,
int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasStrsv");
return func_ptr(uplo, trans, diag, n, A, lda, x, incx);
}
void CUBLASWINAPI cublasDtrsv(char uplo, char trans, char diag, int n,
const double *A, int lda, double *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const double *,
int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasDtrsv");
return func_ptr(uplo, trans, diag, n, A, lda, x, incx);
}
void CUBLASWINAPI cublasCtrsv(char uplo, char trans, char diag, int n,
const cuComplex *A, int lda, cuComplex *x,
int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const cuComplex *,
int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasCtrsv");
return func_ptr(uplo, trans, diag, n, A, lda, x, incx);
}
void CUBLASWINAPI cublasZtrsv(char uplo, char trans, char diag, int n,
const cuDoubleComplex *A, int lda,
cuDoubleComplex *x, int incx) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, char, int, const cuDoubleComplex *, int,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasZtrsv");
return func_ptr(uplo, trans, diag, n, A, lda, x, incx);
}
void CUBLASWINAPI cublasStpsv(char uplo, char trans, char diag, int n,
const float *AP, float *x, int incx) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, char, int, const float *, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStpsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasStpsv");
return func_ptr(uplo, trans, diag, n, AP, x, incx);
}
void CUBLASWINAPI cublasDtpsv(char uplo, char trans, char diag, int n,
const double *AP, double *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const double *,
double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtpsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasDtpsv");
return func_ptr(uplo, trans, diag, n, AP, x, incx);
}
void CUBLASWINAPI cublasCtpsv(char uplo, char trans, char diag, int n,
const cuComplex *AP, cuComplex *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const cuComplex *,
cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtpsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasCtpsv");
return func_ptr(uplo, trans, diag, n, AP, x, incx);
}
void CUBLASWINAPI cublasZtpsv(char uplo, char trans, char diag, int n,
const cuDoubleComplex *AP, cuDoubleComplex *x,
int incx) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, char, int, const cuDoubleComplex *, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtpsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasZtpsv");
return func_ptr(uplo, trans, diag, n, AP, x, incx);
}
void CUBLASWINAPI cublasStbsv(char uplo, char trans, char diag, int n, int k,
const float *A, int lda, float *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, int,
const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStbsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasStbsv");
return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx);
}
void CUBLASWINAPI cublasDtbsv(char uplo, char trans, char diag, int n, int k,
const double *A, int lda, double *x, int incx) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, int,
const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtbsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasDtbsv");
return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx);
}
void CUBLASWINAPI cublasCtbsv(char uplo, char trans, char diag, int n, int k,
const cuComplex *A, int lda, cuComplex *x,
int incx) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, char, int, int, const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtbsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasCtbsv");
return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx);
}
void CUBLASWINAPI cublasZtbsv(char uplo, char trans, char diag, int n, int k,
const cuDoubleComplex *A, int lda,
cuDoubleComplex *x, int incx) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, char, int, int, const cuDoubleComplex *,
int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtbsv");
if (!func_ptr) LogFatalSymbolNotFound("cublasZtbsv");
return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx);
}
void CUBLASWINAPI cublasSsymv(char uplo, int n, float alpha, const float *A,
int lda, const float *x, int incx, float beta,
float *y, int incy) {
using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const float *, int,
const float *, int, float, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsymv");
if (!func_ptr) LogFatalSymbolNotFound("cublasSsymv");
return func_ptr(uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasDsymv(char uplo, int n, double alpha, const double *A,
int lda, const double *x, int incx, double beta,
double *y, int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, double, const double *, int,
const double *, int, double, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsymv");
if (!func_ptr) LogFatalSymbolNotFound("cublasDsymv");
return func_ptr(uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasChemv(char uplo, int n, cuComplex alpha,
const cuComplex *A, int lda, const cuComplex *x,
int incx, cuComplex beta, cuComplex *y,
int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChemv");
if (!func_ptr) LogFatalSymbolNotFound("cublasChemv");
return func_ptr(uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasZhemv(char uplo, int n, cuDoubleComplex alpha,
const cuDoubleComplex *A, int lda,
const cuDoubleComplex *x, int incx,
cuDoubleComplex beta, cuDoubleComplex *y,
int incy) {
using FuncPtr = void(CUBLASWINAPI *)(
char, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhemv");
if (!func_ptr) LogFatalSymbolNotFound("cublasZhemv");
return func_ptr(uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasSsbmv(char uplo, int n, int k, float alpha,
const float *A, int lda, const float *x, int incx,
float beta, float *y, int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, int, float, const float *, int,
const float *, int, float, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasSsbmv");
return func_ptr(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasDsbmv(char uplo, int n, int k, double alpha,
const double *A, int lda, const double *x,
int incx, double beta, double *y, int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, int, double, const double *, int,
const double *, int, double, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasDsbmv");
return func_ptr(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasChbmv(char uplo, int n, int k, cuComplex alpha,
const cuComplex *A, int lda, const cuComplex *x,
int incx, cuComplex beta, cuComplex *y,
int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasChbmv");
return func_ptr(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasZhbmv(char uplo, int n, int k, cuDoubleComplex alpha,
const cuDoubleComplex *A, int lda,
const cuDoubleComplex *x, int incx,
cuDoubleComplex beta, cuDoubleComplex *y,
int incy) {
using FuncPtr = void(CUBLASWINAPI *)(
char, int, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhbmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasZhbmv");
return func_ptr(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasSspmv(char uplo, int n, float alpha, const float *AP,
const float *x, int incx, float beta, float *y,
int incy) {
using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const float *,
const float *, int, float, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasSspmv");
return func_ptr(uplo, n, alpha, AP, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasDspmv(char uplo, int n, double alpha, const double *AP,
const double *x, int incx, double beta, double *y,
int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, double, const double *, const double *,
int, double, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasDspmv");
return func_ptr(uplo, n, alpha, AP, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasChpmv(char uplo, int n, cuComplex alpha,
const cuComplex *AP, const cuComplex *x, int incx,
cuComplex beta, cuComplex *y, int incy) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, cuComplex, const cuComplex *,
const cuComplex *, int, cuComplex, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasChpmv");
return func_ptr(uplo, n, alpha, AP, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasZhpmv(char uplo, int n, cuDoubleComplex alpha,
const cuDoubleComplex *AP,
const cuDoubleComplex *x, int incx,
cuDoubleComplex beta, cuDoubleComplex *y,
int incy) {
using FuncPtr = void(CUBLASWINAPI *)(
char, int, cuDoubleComplex, const cuDoubleComplex *,
const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpmv");
if (!func_ptr) LogFatalSymbolNotFound("cublasZhpmv");
return func_ptr(uplo, n, alpha, AP, x, incx, beta, y, incy);
}
void CUBLASWINAPI cublasSger(int m, int n, float alpha, const float *x,
int incx, const float *y, int incy, float *A,
int lda) {
using FuncPtr = void(CUBLASWINAPI *)(int, int, float, const float *, int,
const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSger");
if (!func_ptr) LogFatalSymbolNotFound("cublasSger");
return func_ptr(m, n, alpha, x, incx, y, incy, A, lda);
}
void CUBLASWINAPI cublasDger(int m, int n, double alpha, const double *x,
int incx, const double *y, int incy, double *A,
int lda) {
using FuncPtr = void(CUBLASWINAPI *)(int, int, double, const double *, int,
const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDger");
if (!func_ptr) LogFatalSymbolNotFound("cublasDger");
return func_ptr(m, n, alpha, x, incx, y, incy, A, lda);
}
void CUBLASWINAPI cublasCgeru(int m, int n, cuComplex alpha, const cuComplex *x,
int incx, const cuComplex *y, int incy,
cuComplex *A, int lda) {
using FuncPtr =
void(CUBLASWINAPI *)(int, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgeru");
if (!func_ptr) LogFatalSymbolNotFound("cublasCgeru");
return func_ptr(m, n, alpha, x, incx, y, incy, A, lda);
}
void CUBLASWINAPI cublasCgerc(int m, int n, cuComplex alpha, const cuComplex *x,
int incx, const cuComplex *y, int incy,
cuComplex *A, int lda) {
using FuncPtr =
void(CUBLASWINAPI *)(int, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgerc");
if (!func_ptr) LogFatalSymbolNotFound("cublasCgerc");
return func_ptr(m, n, alpha, x, incx, y, incy, A, lda);
}
void CUBLASWINAPI cublasZgeru(int m, int n, cuDoubleComplex alpha,
const cuDoubleComplex *x, int incx,
const cuDoubleComplex *y, int incy,
cuDoubleComplex *A, int lda) {
using FuncPtr = void(CUBLASWINAPI *)(
int, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgeru");
if (!func_ptr) LogFatalSymbolNotFound("cublasZgeru");
return func_ptr(m, n, alpha, x, incx, y, incy, A, lda);
}
void CUBLASWINAPI cublasZgerc(int m, int n, cuDoubleComplex alpha,
const cuDoubleComplex *x, int incx,
const cuDoubleComplex *y, int incy,
cuDoubleComplex *A, int lda) {
using FuncPtr = void(CUBLASWINAPI *)(
int, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgerc");
if (!func_ptr) LogFatalSymbolNotFound("cublasZgerc");
return func_ptr(m, n, alpha, x, incx, y, incy, A, lda);
}
void CUBLASWINAPI cublasSsyr(char uplo, int n, float alpha, const float *x,
int incx, float *A, int lda) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, float, const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr");
if (!func_ptr) LogFatalSymbolNotFound("cublasSsyr");
return func_ptr(uplo, n, alpha, x, incx, A, lda);
}
void CUBLASWINAPI cublasDsyr(char uplo, int n, double alpha, const double *x,
int incx, double *A, int lda) {
using FuncPtr = void(CUBLASWINAPI *)(char, int, double, const double *, int,
double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr");
if (!func_ptr) LogFatalSymbolNotFound("cublasDsyr");
return func_ptr(uplo, n, alpha, x, incx, A, lda);
}
void CUBLASWINAPI cublasCher(char uplo, int n, float alpha, const cuComplex *x,
int incx, cuComplex *A, int lda) {
using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const cuComplex *, int,
cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher");
if (!func_ptr) LogFatalSymbolNotFound("cublasCher");
return func_ptr(uplo, n, alpha, x, incx, A, lda);
}
void CUBLASWINAPI cublasZher(char uplo, int n, double alpha,
const cuDoubleComplex *x, int incx,
cuDoubleComplex *A, int lda) {
using FuncPtr = void(CUBLASWINAPI *)(
char, int, double, const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher");
if (!func_ptr) LogFatalSymbolNotFound("cublasZher");
return func_ptr(uplo, n, alpha, x, incx, A, lda);
}
void CUBLASWINAPI cublasSspr(char uplo, int n, float alpha, const float *x,
int incx, float *AP) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, float, const float *, int, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspr");
if (!func_ptr) LogFatalSymbolNotFound("cublasSspr");
return func_ptr(uplo, n, alpha, x, incx, AP);
}
void CUBLASWINAPI cublasDspr(char uplo, int n, double alpha, const double *x,
int incx, double *AP) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, double, const double *, int, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspr");
if (!func_ptr) LogFatalSymbolNotFound("cublasDspr");
return func_ptr(uplo, n, alpha, x, incx, AP);
}
void CUBLASWINAPI cublasChpr(char uplo, int n, float alpha, const cuComplex *x,
int incx, cuComplex *AP) {
using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const cuComplex *, int,
cuComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpr");
if (!func_ptr) LogFatalSymbolNotFound("cublasChpr");
return func_ptr(uplo, n, alpha, x, incx, AP);
}
void CUBLASWINAPI cublasZhpr(char uplo, int n, double alpha,
const cuDoubleComplex *x, int incx,
cuDoubleComplex *AP) {
using FuncPtr = void(CUBLASWINAPI *)(
char, int, double, const cuDoubleComplex *, int, cuDoubleComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpr");
if (!func_ptr) LogFatalSymbolNotFound("cublasZhpr");
return func_ptr(uplo, n, alpha, x, incx, AP);
}
void CUBLASWINAPI cublasSsyr2(char uplo, int n, float alpha, const float *x,
int incx, const float *y, int incy, float *A,
int lda) {
using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const float *, int,
const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr2");
if (!func_ptr) LogFatalSymbolNotFound("cublasSsyr2");
return func_ptr(uplo, n, alpha, x, incx, y, incy, A, lda);
}
void CUBLASWINAPI cublasDsyr2(char uplo, int n, double alpha, const double *x,
int incx, const double *y, int incy, double *A,
int lda) {
using FuncPtr = void(CUBLASWINAPI *)(char, int, double, const double *, int,
const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr2");
if (!func_ptr) LogFatalSymbolNotFound("cublasDsyr2");
return func_ptr(uplo, n, alpha, x, incx, y, incy, A, lda);
}
void CUBLASWINAPI cublasCher2(char uplo, int n, cuComplex alpha,
const cuComplex *x, int incx, const cuComplex *y,
int incy, cuComplex *A, int lda) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher2");
if (!func_ptr) LogFatalSymbolNotFound("cublasCher2");
return func_ptr(uplo, n, alpha, x, incx, y, incy, A, lda);
}
void CUBLASWINAPI cublasZher2(char uplo, int n, cuDoubleComplex alpha,
const cuDoubleComplex *x, int incx,
const cuDoubleComplex *y, int incy,
cuDoubleComplex *A, int lda) {
using FuncPtr = void(CUBLASWINAPI *)(
char, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher2");
if (!func_ptr) LogFatalSymbolNotFound("cublasZher2");
return func_ptr(uplo, n, alpha, x, incx, y, incy, A, lda);
}
void CUBLASWINAPI cublasSspr2(char uplo, int n, float alpha, const float *x,
int incx, const float *y, int incy, float *AP) {
using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const float *, int,
const float *, int, float *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspr2");
if (!func_ptr) LogFatalSymbolNotFound("cublasSspr2");
return func_ptr(uplo, n, alpha, x, incx, y, incy, AP);
}
void CUBLASWINAPI cublasDspr2(char uplo, int n, double alpha, const double *x,
int incx, const double *y, int incy, double *AP) {
using FuncPtr = void(CUBLASWINAPI *)(char, int, double, const double *, int,
const double *, int, double *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspr2");
if (!func_ptr) LogFatalSymbolNotFound("cublasDspr2");
return func_ptr(uplo, n, alpha, x, incx, y, incy, AP);
}
void CUBLASWINAPI cublasChpr2(char uplo, int n, cuComplex alpha,
const cuComplex *x, int incx, const cuComplex *y,
int incy, cuComplex *AP) {
using FuncPtr =
void(CUBLASWINAPI *)(char, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpr2");
if (!func_ptr) LogFatalSymbolNotFound("cublasChpr2");
return func_ptr(uplo, n, alpha, x, incx, y, incy, AP);
}
void CUBLASWINAPI cublasZhpr2(char uplo, int n, cuDoubleComplex alpha,
const cuDoubleComplex *x, int incx,
const cuDoubleComplex *y, int incy,
cuDoubleComplex *AP) {
using FuncPtr = void(CUBLASWINAPI *)(
char, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex *);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpr2");
if (!func_ptr) LogFatalSymbolNotFound("cublasZhpr2");
return func_ptr(uplo, n, alpha, x, incx, y, incy, AP);
}
void CUBLASWINAPI cublasSgemm(char transa, char transb, int m, int n, int k,
float alpha, const float *A, int lda,
const float *B, int ldb, float beta, float *C,
int ldc) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, int, int, int, float, const float *, int,
const float *, int, float, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemm");
if (!func_ptr) LogFatalSymbolNotFound("cublasSgemm");
return func_ptr(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasDgemm(char transa, char transb, int m, int n, int k,
double alpha, const double *A, int lda,
const double *B, int ldb, double beta, double *C,
int ldc) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, int, int, int, double, const double *,
int, const double *, int, double, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemm");
if (!func_ptr) LogFatalSymbolNotFound("cublasDgemm");
return func_ptr(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasCgemm(char transa, char transb, int m, int n, int k,
cuComplex alpha, const cuComplex *A, int lda,
const cuComplex *B, int ldb, cuComplex beta,
cuComplex *C, int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, int, int, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm");
if (!func_ptr) LogFatalSymbolNotFound("cublasCgemm");
return func_ptr(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasZgemm(char transa, char transb, int m, int n, int k,
cuDoubleComplex alpha, const cuDoubleComplex *A,
int lda, const cuDoubleComplex *B, int ldb,
cuDoubleComplex beta, cuDoubleComplex *C,
int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, int, int, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemm");
if (!func_ptr) LogFatalSymbolNotFound("cublasZgemm");
return func_ptr(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasSsyrk(char uplo, char trans, int n, int k, float alpha,
const float *A, int lda, float beta, float *C,
int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, int, int, float,
const float *, int, float, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyrk");
if (!func_ptr) LogFatalSymbolNotFound("cublasSsyrk");
return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
void CUBLASWINAPI cublasDsyrk(char uplo, char trans, int n, int k, double alpha,
const double *A, int lda, double beta, double *C,
int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, int, int, double, const double *, int, double, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyrk");
if (!func_ptr) LogFatalSymbolNotFound("cublasDsyrk");
return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
void CUBLASWINAPI cublasCsyrk(char uplo, char trans, int n, int k,
cuComplex alpha, const cuComplex *A, int lda,
cuComplex beta, cuComplex *C, int ldc) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, int, int, cuComplex, const cuComplex *,
int, cuComplex, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyrk");
if (!func_ptr) LogFatalSymbolNotFound("cublasCsyrk");
return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
void CUBLASWINAPI cublasZsyrk(char uplo, char trans, int n, int k,
cuDoubleComplex alpha, const cuDoubleComplex *A,
int lda, cuDoubleComplex beta, cuDoubleComplex *C,
int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, int, int, cuDoubleComplex,
const cuDoubleComplex *, int,
cuDoubleComplex, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyrk");
if (!func_ptr) LogFatalSymbolNotFound("cublasZsyrk");
return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
void CUBLASWINAPI cublasCherk(char uplo, char trans, int n, int k, float alpha,
const cuComplex *A, int lda, float beta,
cuComplex *C, int ldc) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, int, int, float, const cuComplex *, int,
float, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCherk");
if (!func_ptr) LogFatalSymbolNotFound("cublasCherk");
return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
void CUBLASWINAPI cublasZherk(char uplo, char trans, int n, int k, double alpha,
const cuDoubleComplex *A, int lda, double beta,
cuDoubleComplex *C, int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, int, int, double,
const cuDoubleComplex *, int, double,
cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZherk");
if (!func_ptr) LogFatalSymbolNotFound("cublasZherk");
return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}
void CUBLASWINAPI cublasSsyr2k(char uplo, char trans, int n, int k, float alpha,
const float *A, int lda, const float *B, int ldb,
float beta, float *C, int ldc) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, int, int, float, const float *, int,
const float *, int, float, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr2k");
if (!func_ptr) LogFatalSymbolNotFound("cublasSsyr2k");
return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasDsyr2k(char uplo, char trans, int n, int k,
double alpha, const double *A, int lda,
const double *B, int ldb, double beta, double *C,
int ldc) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, int, int, double, const double *, int,
const double *, int, double, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr2k");
if (!func_ptr) LogFatalSymbolNotFound("cublasDsyr2k");
return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasCsyr2k(char uplo, char trans, int n, int k,
cuComplex alpha, const cuComplex *A, int lda,
const cuComplex *B, int ldb, cuComplex beta,
cuComplex *C, int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, int, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyr2k");
if (!func_ptr) LogFatalSymbolNotFound("cublasCsyr2k");
return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasZsyr2k(char uplo, char trans, int n, int k,
cuDoubleComplex alpha, const cuDoubleComplex *A,
int lda, const cuDoubleComplex *B, int ldb,
cuDoubleComplex beta, cuDoubleComplex *C,
int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyr2k");
if (!func_ptr) LogFatalSymbolNotFound("cublasZsyr2k");
return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasCher2k(char uplo, char trans, int n, int k,
cuComplex alpha, const cuComplex *A, int lda,
const cuComplex *B, int ldb, float beta,
cuComplex *C, int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, int, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, float, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher2k");
if (!func_ptr) LogFatalSymbolNotFound("cublasCher2k");
return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasZher2k(char uplo, char trans, int n, int k,
cuDoubleComplex alpha, const cuDoubleComplex *A,
int lda, const cuDoubleComplex *B, int ldb,
double beta, cuDoubleComplex *C, int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, double, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher2k");
if (!func_ptr) LogFatalSymbolNotFound("cublasZher2k");
return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasSsymm(char side, char uplo, int m, int n, float alpha,
const float *A, int lda, const float *B, int ldb,
float beta, float *C, int ldc) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, int, int, float, const float *, int,
const float *, int, float, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsymm");
if (!func_ptr) LogFatalSymbolNotFound("cublasSsymm");
return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasDsymm(char side, char uplo, int m, int n, double alpha,
const double *A, int lda, const double *B,
int ldb, double beta, double *C, int ldc) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, int, int, double, const double *, int,
const double *, int, double, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsymm");
if (!func_ptr) LogFatalSymbolNotFound("cublasDsymm");
return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasCsymm(char side, char uplo, int m, int n,
cuComplex alpha, const cuComplex *A, int lda,
const cuComplex *B, int ldb, cuComplex beta,
cuComplex *C, int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, int, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsymm");
if (!func_ptr) LogFatalSymbolNotFound("cublasCsymm");
return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasZsymm(char side, char uplo, int m, int n,
cuDoubleComplex alpha, const cuDoubleComplex *A,
int lda, const cuDoubleComplex *B, int ldb,
cuDoubleComplex beta, cuDoubleComplex *C,
int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsymm");
if (!func_ptr) LogFatalSymbolNotFound("cublasZsymm");
return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasChemm(char side, char uplo, int m, int n,
cuComplex alpha, const cuComplex *A, int lda,
const cuComplex *B, int ldb, cuComplex beta,
cuComplex *C, int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, int, int, cuComplex, const cuComplex *, int,
const cuComplex *, int, cuComplex, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasChemm");
if (!func_ptr) LogFatalSymbolNotFound("cublasChemm");
return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasZhemm(char side, char uplo, int m, int n,
cuDoubleComplex alpha, const cuDoubleComplex *A,
int lda, const cuDoubleComplex *B, int ldb,
cuDoubleComplex beta, cuDoubleComplex *C,
int ldc) {
using FuncPtr = void(CUBLASWINAPI *)(
char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int,
const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhemm");
if (!func_ptr) LogFatalSymbolNotFound("cublasZhemm");
return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}
void CUBLASWINAPI cublasStrsm(char side, char uplo, char transa, char diag,
int m, int n, float alpha, const float *A,
int lda, float *B, int ldb) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int, float,
const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrsm");
if (!func_ptr) LogFatalSymbolNotFound("cublasStrsm");
return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}
void CUBLASWINAPI cublasDtrsm(char side, char uplo, char transa, char diag,
int m, int n, double alpha, const double *A,
int lda, double *B, int ldb) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int, double,
const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrsm");
if (!func_ptr) LogFatalSymbolNotFound("cublasDtrsm");
return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}
void CUBLASWINAPI cublasCtrsm(char side, char uplo, char transa, char diag,
int m, int n, cuComplex alpha, const cuComplex *A,
int lda, cuComplex *B, int ldb) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, char, char, int, int, cuComplex,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrsm");
if (!func_ptr) LogFatalSymbolNotFound("cublasCtrsm");
return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}
void CUBLASWINAPI cublasZtrsm(char side, char uplo, char transa, char diag,
int m, int n, cuDoubleComplex alpha,
const cuDoubleComplex *A, int lda,
cuDoubleComplex *B, int ldb) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int,
cuDoubleComplex, const cuDoubleComplex *,
int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrsm");
if (!func_ptr) LogFatalSymbolNotFound("cublasZtrsm");
return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}
void CUBLASWINAPI cublasStrmm(char side, char uplo, char transa, char diag,
int m, int n, float alpha, const float *A,
int lda, float *B, int ldb) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int, float,
const float *, int, float *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrmm");
if (!func_ptr) LogFatalSymbolNotFound("cublasStrmm");
return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}
void CUBLASWINAPI cublasDtrmm(char side, char uplo, char transa, char diag,
int m, int n, double alpha, const double *A,
int lda, double *B, int ldb) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int, double,
const double *, int, double *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrmm");
if (!func_ptr) LogFatalSymbolNotFound("cublasDtrmm");
return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}
void CUBLASWINAPI cublasCtrmm(char side, char uplo, char transa, char diag,
int m, int n, cuComplex alpha, const cuComplex *A,
int lda, cuComplex *B, int ldb) {
using FuncPtr =
void(CUBLASWINAPI *)(char, char, char, char, int, int, cuComplex,
const cuComplex *, int, cuComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrmm");
if (!func_ptr) LogFatalSymbolNotFound("cublasCtrmm");
return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}
void CUBLASWINAPI cublasZtrmm(char side, char uplo, char transa, char diag,
int m, int n, cuDoubleComplex alpha,
const cuDoubleComplex *A, int lda,
cuDoubleComplex *B, int ldb) {
using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int,
cuDoubleComplex, const cuDoubleComplex *,
int, cuDoubleComplex *, int);
static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrmm");
if (!func_ptr) LogFatalSymbolNotFound("cublasZtrmm");
return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}
} // extern "C"