diff --git a/tensorflow/compiler/xla/service/gpu/BUILD b/tensorflow/compiler/xla/service/gpu/BUILD
index 477768a137b..2cc47841886 100644
--- a/tensorflow/compiler/xla/service/gpu/BUILD
+++ b/tensorflow/compiler/xla/service/gpu/BUILD
@@ -5,6 +5,7 @@ load("//tensorflow/compiler/xla/tests:build_defs.bzl", "xla_test")
load("//tensorflow/compiler/xla:xla.bzl", "xla_proto_library")
load(
"//tensorflow/core:platform/default/build_config_root.bzl",
+ "if_static",
"tf_cuda_tests_tags",
)
load("//tensorflow:tensorflow.bzl", "tf_cc_test", "tf_cuda_library")
@@ -598,15 +599,17 @@ cc_library(
srcs = ["cusolver_context.cc"],
hdrs = ["cusolver_context.h"],
deps = [
+ "@local_config_cuda//cuda:cuda_headers",
"//tensorflow/compiler/xla:statusor",
"//tensorflow/compiler/xla:types",
"//tensorflow/compiler/xla:util",
"//tensorflow/core:lib",
"//tensorflow/core:stream_executor_no_cuda",
"//tensorflow/stream_executor:blas",
- "@local_config_cuda//cuda:cuda_headers",
- "@local_config_cuda//cuda:cusolver",
- ],
+ ] + if_static(
+ ["@local_config_cuda//cuda:cusolver"],
+ ["//tensorflow/stream_executor/cuda:cusolver_stub"],
+ ),
)
cc_library(
diff --git a/tensorflow/core/kernels/BUILD b/tensorflow/core/kernels/BUILD
index 28a85c1de0f..e2e32ed85c7 100644
--- a/tensorflow/core/kernels/BUILD
+++ b/tensorflow/core/kernels/BUILD
@@ -53,6 +53,7 @@ load(
)
load(
"//tensorflow/core:platform/default/build_config_root.bzl",
+ "if_static",
"tf_cuda_tests_tags",
)
load(
@@ -3030,9 +3031,16 @@ tf_kernel_library(
"//tensorflow/core:framework",
"//tensorflow/core:lib",
"//tensorflow/core/platform/default/build_config:cublas_plugin",
- "@local_config_cuda//cuda:cublas",
- "@local_config_cuda//cuda:cusolver",
- ],
+ ] + if_static(
+ [
+ "@local_config_cuda//cuda:cusolver",
+ "@local_config_cuda//cuda:cublas",
+ ],
+ [
+ "//tensorflow/stream_executor/cuda:cusolver_stub",
+ "//tensorflow/stream_executor/cuda:cublas_stub",
+ ],
+ ),
)
tf_kernel_library(
@@ -3042,8 +3050,10 @@ tf_kernel_library(
deps = [
"//tensorflow/core:framework",
"//tensorflow/core:lib",
- "@local_config_cuda//cuda:cusparse",
- ],
+ ] + if_static(
+ ["@local_config_cuda//cuda:cusparse"],
+ ["//tensorflow/stream_executor/cuda:cusparse_stub"],
+ ),
)
LINALG_DEPS = [
diff --git a/tensorflow/stream_executor/cuda/BUILD b/tensorflow/stream_executor/cuda/BUILD
index be27d9784b6..d458d36e403 100644
--- a/tensorflow/stream_executor/cuda/BUILD
+++ b/tensorflow/stream_executor/cuda/BUILD
@@ -350,6 +350,28 @@ cc_library(
]),
)
+cc_library(
+ name = "cusolver_stub",
+ srcs = if_cuda_is_configured(["cusolver_stub.cc"]),
+ textual_hdrs = ["cusolver_dense_10_0.inc"],
+ deps = if_cuda_is_configured([
+ "@local_config_cuda//cuda:cuda_headers",
+ "//tensorflow/stream_executor/lib",
+ "//tensorflow/stream_executor/platform:dso_loader",
+ ]),
+)
+
+cc_library(
+ name = "cusparse_stub",
+ srcs = if_cuda_is_configured(["cusparse_stub.cc"]),
+ textual_hdrs = glob(["cusparse_*.inc"]),
+ deps = if_cuda_is_configured([
+ "@local_config_cuda//cuda:cuda_headers",
+ "//tensorflow/stream_executor/lib",
+ "//tensorflow/stream_executor/platform:dso_loader",
+ ]),
+)
+
cc_library(
name = "cuda_kernel",
srcs = if_cuda_is_configured(["cuda_kernel.cc"]),
diff --git a/tensorflow/stream_executor/cuda/cusolver_dense_10_0.inc b/tensorflow/stream_executor/cuda/cusolver_dense_10_0.inc
new file mode 100644
index 00000000000..d01117faeb2
--- /dev/null
+++ b/tensorflow/stream_executor/cuda/cusolver_dense_10_0.inc
@@ -0,0 +1,2283 @@
+// Auto-generated, do not edit.
+
+extern "C" {
+
+cusolverStatus_t CUSOLVERAPI cusolverGetProperty(libraryPropertyType type,
+ int *value) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(libraryPropertyType, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverGetProperty");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(type, value);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCreate(cusolverDnHandle_t *handle) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCreate");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDestroy(cusolverDnHandle_t handle) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDestroy");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSetStream(cusolverDnHandle_t handle,
+ cudaStream_t streamId) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cudaStream_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSetStream");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, streamId);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnGetStream(cusolverDnHandle_t handle,
+ cudaStream_t *streamId) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cudaStream_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnGetStream");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, streamId);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnSpotrf_bufferSize(cusolverDnHandle_t handle, cublasFillMode_t uplo,
+ int n, float *A, int lda, int *Lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSpotrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnDpotrf_bufferSize(cusolverDnHandle_t handle, cublasFillMode_t uplo,
+ int n, double *A, int lda, int *Lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDpotrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnCpotrf_bufferSize(cusolverDnHandle_t handle, cublasFillMode_t uplo,
+ int n, cuComplex *A, int lda, int *Lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCpotrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnZpotrf_bufferSize(cusolverDnHandle_t handle, cublasFillMode_t uplo,
+ int n, cuDoubleComplex *A, int lda, int *Lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZpotrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSpotrf(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ float *A, int lda,
+ float *Workspace, int Lwork,
+ int *devInfo) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
+ float *, int, float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSpotrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, Workspace, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDpotrf(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ double *A, int lda,
+ double *Workspace, int Lwork,
+ int *devInfo) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
+ double *, int, double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDpotrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, Workspace, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCpotrf(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ cuComplex *A, int lda,
+ cuComplex *Workspace, int Lwork,
+ int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, cuComplex *, int, cuComplex *,
+ int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCpotrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, Workspace, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZpotrf(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ cuDoubleComplex *A, int lda,
+ cuDoubleComplex *Workspace,
+ int Lwork, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, cuDoubleComplex *, int,
+ cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZpotrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, Workspace, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSpotrs(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ int nrhs, const float *A, int lda,
+ float *B, int ldb, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, int, const float *, int,
+ float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSpotrs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDpotrs(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ int nrhs, const double *A,
+ int lda, double *B, int ldb,
+ int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, int, const double *, int,
+ double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDpotrs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCpotrs(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ int nrhs, const cuComplex *A,
+ int lda, cuComplex *B, int ldb,
+ int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, int, const cuComplex *, int,
+ cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCpotrs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZpotrs(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ int nrhs,
+ const cuDoubleComplex *A, int lda,
+ cuDoubleComplex *B, int ldb,
+ int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, int, const cuDoubleComplex *,
+ int, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZpotrs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSpotrfBatched(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo,
+ int n, float *Aarray[],
+ int lda, int *infoArray,
+ int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, float *[], int, int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSpotrfBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, Aarray, lda, infoArray, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDpotrfBatched(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo,
+ int n, double *Aarray[],
+ int lda, int *infoArray,
+ int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, double *[], int, int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDpotrfBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, Aarray, lda, infoArray, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCpotrfBatched(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo,
+ int n, cuComplex *Aarray[],
+ int lda, int *infoArray,
+ int batchSize) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
+ cuComplex *[], int, int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCpotrfBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, Aarray, lda, infoArray, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZpotrfBatched(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
+ cuDoubleComplex *Aarray[], int lda, int *infoArray, int batchSize) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
+ cuDoubleComplex *[], int, int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZpotrfBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, Aarray, lda, infoArray, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSpotrsBatched(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
+ int nrhs, /* only support rhs = 1*/
+ float *A[], int lda, float *B[], int ldb, int *d_info, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, int, float *[], int, float *[],
+ int, int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSpotrsBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, d_info, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDpotrsBatched(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
+ int nrhs, /* only support rhs = 1*/
+ double *A[], int lda, double *B[], int ldb, int *d_info, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, int, double *[], int,
+ double *[], int, int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDpotrsBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, d_info, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnCpotrsBatched(cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
+ int nrhs, /* only support rhs = 1*/
+ cuComplex *A[], int lda, cuComplex *B[], int ldb,
+ int *d_info, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, int, cuComplex *[], int,
+ cuComplex *[], int, int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCpotrsBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, d_info, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnZpotrsBatched(cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
+ int nrhs, /* only support rhs = 1*/
+ cuDoubleComplex *A[], int lda, cuDoubleComplex *B[],
+ int ldb, int *d_info, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, int, cuDoubleComplex *[], int,
+ cuDoubleComplex *[], int, int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZpotrsBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, d_info, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgetrf_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, float *A, int lda, int *Lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
+ float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgetrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgetrf_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, double *A, int lda, int *Lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
+ double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgetrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnCgetrf_bufferSize(cusolverDnHandle_t handle, int m, int n,
+ cuComplex *A, int lda, int *Lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
+ cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgetrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnZgetrf_bufferSize(cusolverDnHandle_t handle, int m, int n,
+ cuDoubleComplex *A, int lda, int *Lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgetrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgetrf(cusolverDnHandle_t handle, int m,
+ int n, float *A, int lda,
+ float *Workspace, int *devIpiv,
+ int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, float *, int, float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgetrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, Workspace, devIpiv, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgetrf(cusolverDnHandle_t handle, int m,
+ int n, double *A, int lda,
+ double *Workspace, int *devIpiv,
+ int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, double *, int, double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgetrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, Workspace, devIpiv, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCgetrf(cusolverDnHandle_t handle, int m,
+ int n, cuComplex *A, int lda,
+ cuComplex *Workspace,
+ int *devIpiv, int *devInfo) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, cuComplex *,
+ int, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgetrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, Workspace, devIpiv, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZgetrf(cusolverDnHandle_t handle, int m,
+ int n, cuDoubleComplex *A,
+ int lda,
+ cuDoubleComplex *Workspace,
+ int *devIpiv, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, cuDoubleComplex *, int, cuDoubleComplex *,
+ int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgetrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, Workspace, devIpiv, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSlaswp(cusolverDnHandle_t handle, int n,
+ float *A, int lda, int k1, int k2,
+ const int *devIpiv, int incx) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, float *, int, int, int, const int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSlaswp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, n, A, lda, k1, k2, devIpiv, incx);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDlaswp(cusolverDnHandle_t handle, int n,
+ double *A, int lda, int k1,
+ int k2, const int *devIpiv,
+ int incx) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, double *, int, int, int, const int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDlaswp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, n, A, lda, k1, k2, devIpiv, incx);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnClaswp(cusolverDnHandle_t handle, int n,
+ cuComplex *A, int lda, int k1,
+ int k2, const int *devIpiv,
+ int incx) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, cuComplex *, int, int, int, const int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnClaswp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, n, A, lda, k1, k2, devIpiv, incx);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZlaswp(cusolverDnHandle_t handle, int n,
+ cuDoubleComplex *A, int lda,
+ int k1, int k2,
+ const int *devIpiv, int incx) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int,
+ cuDoubleComplex *, int, int,
+ int, const int *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZlaswp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, n, A, lda, k1, k2, devIpiv, incx);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgetrs(cusolverDnHandle_t handle,
+ cublasOperation_t trans, int n,
+ int nrhs, const float *A, int lda,
+ const int *devIpiv, float *B,
+ int ldb, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasOperation_t, int, int, const float *, int,
+ const int *, float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgetrs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgetrs(cusolverDnHandle_t handle,
+ cublasOperation_t trans, int n,
+ int nrhs, const double *A,
+ int lda, const int *devIpiv,
+ double *B, int ldb,
+ int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasOperation_t, int, int, const double *, int,
+ const int *, double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgetrs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCgetrs(cusolverDnHandle_t handle,
+ cublasOperation_t trans, int n,
+ int nrhs, const cuComplex *A,
+ int lda, const int *devIpiv,
+ cuComplex *B, int ldb,
+ int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasOperation_t, int, int, const cuComplex *, int,
+ const int *, cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgetrs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZgetrs(
+ cusolverDnHandle_t handle, cublasOperation_t trans, int n, int nrhs,
+ const cuDoubleComplex *A, int lda, const int *devIpiv, cuDoubleComplex *B,
+ int ldb, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasOperation_t, int, int, const cuDoubleComplex *,
+ int, const int *, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgetrs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgeqrf_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, float *A, int lda, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
+ float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgeqrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgeqrf_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, double *A, int lda, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
+ double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgeqrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnCgeqrf_bufferSize(cusolverDnHandle_t handle, int m, int n,
+ cuComplex *A, int lda, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
+ cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgeqrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnZgeqrf_bufferSize(cusolverDnHandle_t handle, int m, int n,
+ cuDoubleComplex *A, int lda, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgeqrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgeqrf(cusolverDnHandle_t handle, int m,
+ int n, float *A, int lda,
+ float *TAU, float *Workspace,
+ int Lwork, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, float *, int, float *, float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgeqrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, TAU, Workspace, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgeqrf(cusolverDnHandle_t handle, int m,
+ int n, double *A, int lda,
+ double *TAU, double *Workspace,
+ int Lwork, int *devInfo) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, double *,
+ int, double *, double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgeqrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, TAU, Workspace, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCgeqrf(cusolverDnHandle_t handle, int m,
+ int n, cuComplex *A, int lda,
+ cuComplex *TAU,
+ cuComplex *Workspace, int Lwork,
+ int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
+ cuComplex *, int, cuComplex *,
+ cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgeqrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, TAU, Workspace, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZgeqrf(cusolverDnHandle_t handle, int m,
+ int n, cuDoubleComplex *A,
+ int lda, cuDoubleComplex *TAU,
+ cuDoubleComplex *Workspace,
+ int Lwork, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, cuDoubleComplex *, int, cuDoubleComplex *,
+ cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgeqrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, TAU, Workspace, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSorgqr_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int k, const float *A, int lda,
+ const float *tau, int *lwork) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int,
+ const float *, int, const float *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgqr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDorgqr_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int k, const double *A, int lda,
+ const double *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
+ int, const double *, int,
+ const double *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgqr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCungqr_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int k, const cuComplex *A, int lda,
+ const cuComplex *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
+ int, const cuComplex *, int,
+ const cuComplex *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungqr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZungqr_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int k, const cuDoubleComplex *A,
+ int lda, const cuDoubleComplex *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, int, const cuDoubleComplex *, int,
+ const cuDoubleComplex *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungqr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSorgqr(cusolverDnHandle_t handle, int m,
+ int n, int k, float *A, int lda,
+ const float *tau, float *work,
+ int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, int, float *, int, const float *, float *,
+ int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgqr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDorgqr(cusolverDnHandle_t handle, int m,
+ int n, int k, double *A, int lda,
+ const double *tau, double *work,
+ int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, int, double *, int, const double *,
+ double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgqr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCungqr(cusolverDnHandle_t handle, int m,
+ int n, int k, cuComplex *A,
+ int lda, const cuComplex *tau,
+ cuComplex *work, int lwork,
+ int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, int, cuComplex *, int, const cuComplex *,
+ cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungqr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZungqr(
+ cusolverDnHandle_t handle, int m, int n, int k, cuDoubleComplex *A, int lda,
+ const cuDoubleComplex *tau, cuDoubleComplex *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, int, cuDoubleComplex *, int,
+ const cuDoubleComplex *, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungqr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSormqr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
+ int m, int n, int k, const float *A, int lda, const float *tau,
+ const float *C, int ldc, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
+ const float *, int, const float *, const float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSormqr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDormqr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
+ int m, int n, int k, const double *A, int lda, const double *tau,
+ const double *C, int ldc, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
+ const double *, int, const double *, const double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDormqr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCunmqr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
+ int m, int n, int k, const cuComplex *A, int lda, const cuComplex *tau,
+ const cuComplex *C, int ldc, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
+ const cuComplex *, int, const cuComplex *, const cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCunmqr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZunmqr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
+ int m, int n, int k, const cuDoubleComplex *A, int lda,
+ const cuDoubleComplex *tau, const cuDoubleComplex *C, int ldc, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
+ const cuDoubleComplex *, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZunmqr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSormqr(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
+ int m, int n, int k, const float *A, int lda, const float *tau, float *C,
+ int ldc, float *work, int lwork, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
+ const float *, int, const float *, float *, int, float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSormqr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, work,
+ lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDormqr(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
+ int m, int n, int k, const double *A, int lda, const double *tau, double *C,
+ int ldc, double *work, int lwork, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
+ const double *, int, const double *, double *, int, double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDormqr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, work,
+ lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCunmqr(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
+ int m, int n, int k, const cuComplex *A, int lda, const cuComplex *tau,
+ cuComplex *C, int ldc, cuComplex *work, int lwork, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
+ const cuComplex *, int, const cuComplex *, cuComplex *, int, cuComplex *,
+ int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCunmqr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, work,
+ lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZunmqr(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
+ int m, int n, int k, const cuDoubleComplex *A, int lda,
+ const cuDoubleComplex *tau, cuDoubleComplex *C, int ldc,
+ cuDoubleComplex *work, int lwork, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
+ const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
+ int, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZunmqr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, work,
+ lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsytrf_bufferSize(
+ cusolverDnHandle_t handle, int n, float *A, int lda, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int,
+ float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsytrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, n, A, lda, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsytrf_bufferSize(
+ cusolverDnHandle_t handle, int n, double *A, int lda, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int,
+ double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsytrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, n, A, lda, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCsytrf_bufferSize(
+ cusolverDnHandle_t handle, int n, cuComplex *A, int lda, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int,
+ cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCsytrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, n, A, lda, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZsytrf_bufferSize(
+ cusolverDnHandle_t handle, int n, cuDoubleComplex *A, int lda, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZsytrf_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, n, A, lda, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsytrf(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ float *A, int lda, int *ipiv,
+ float *work, int lwork,
+ int *info) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
+ float *, int, int *, float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsytrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, ipiv, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsytrf(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ double *A, int lda, int *ipiv,
+ double *work, int lwork,
+ int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, double *, int, int *, double *,
+ int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsytrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, ipiv, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCsytrf(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ cuComplex *A, int lda, int *ipiv,
+ cuComplex *work, int lwork,
+ int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, cuComplex *, int, int *,
+ cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCsytrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, ipiv, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZsytrf(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ cuDoubleComplex *A, int lda,
+ int *ipiv, cuDoubleComplex *work,
+ int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, cuDoubleComplex *, int, int *,
+ cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZsytrf");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, ipiv, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgebrd_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int *Lwork) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgebrd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgebrd_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int *Lwork) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgebrd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCgebrd_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int *Lwork) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgebrd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZgebrd_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int *Lwork) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgebrd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, Lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgebrd(cusolverDnHandle_t handle, int m,
+ int n, float *A, int lda,
+ float *D, float *E, float *TAUQ,
+ float *TAUP, float *Work,
+ int Lwork, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, float *, int, float *, float *, float *,
+ float *, float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgebrd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, D, E, TAUQ, TAUP, Work, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgebrd(cusolverDnHandle_t handle, int m,
+ int n, double *A, int lda,
+ double *D, double *E,
+ double *TAUQ, double *TAUP,
+ double *Work, int Lwork,
+ int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, double *, int, double *, double *, double *,
+ double *, double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgebrd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, D, E, TAUQ, TAUP, Work, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCgebrd(cusolverDnHandle_t handle, int m,
+ int n, cuComplex *A, int lda,
+ float *D, float *E,
+ cuComplex *TAUQ, cuComplex *TAUP,
+ cuComplex *Work, int Lwork,
+ int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, cuComplex *, int, float *, float *,
+ cuComplex *, cuComplex *, cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgebrd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, D, E, TAUQ, TAUP, Work, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZgebrd(
+ cusolverDnHandle_t handle, int m, int n, cuDoubleComplex *A, int lda,
+ double *D, double *E, cuDoubleComplex *TAUQ, cuDoubleComplex *TAUP,
+ cuDoubleComplex *Work, int Lwork, int *devInfo) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, int, int, cuDoubleComplex *, int, double *, double *,
+ cuDoubleComplex *, cuDoubleComplex *, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgebrd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, D, E, TAUQ, TAUP, Work, Lwork, devInfo);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSorgbr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, int m, int n, int k,
+ const float *A, int lda, const float *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, int, int, int, const float *, int,
+ const float *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgbr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, m, n, k, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDorgbr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, int m, int n, int k,
+ const double *A, int lda, const double *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, int, int, int, const double *, int,
+ const double *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgbr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, m, n, k, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCungbr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, int m, int n, int k,
+ const cuComplex *A, int lda, const cuComplex *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, int, int, int, const cuComplex *,
+ int, const cuComplex *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungbr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, m, n, k, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZungbr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, int m, int n, int k,
+ const cuDoubleComplex *A, int lda, const cuDoubleComplex *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, int, int, int,
+ const cuDoubleComplex *, int, const cuDoubleComplex *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungbr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, m, n, k, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSorgbr(cusolverDnHandle_t handle,
+ cublasSideMode_t side, int m,
+ int n, int k, float *A, int lda,
+ const float *tau, float *work,
+ int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, int, int, int, float *, int,
+ const float *, float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgbr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, m, n, k, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDorgbr(cusolverDnHandle_t handle,
+ cublasSideMode_t side, int m,
+ int n, int k, double *A, int lda,
+ const double *tau, double *work,
+ int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, int, int, int, double *, int,
+ const double *, double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgbr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, m, n, k, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCungbr(cusolverDnHandle_t handle,
+ cublasSideMode_t side, int m,
+ int n, int k, cuComplex *A,
+ int lda, const cuComplex *tau,
+ cuComplex *work, int lwork,
+ int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, int, int, int, cuComplex *, int,
+ const cuComplex *, cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungbr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, m, n, k, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnZungbr(cusolverDnHandle_t handle, cublasSideMode_t side, int m, int n,
+ int k, cuDoubleComplex *A, int lda, const cuDoubleComplex *tau,
+ cuDoubleComplex *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, int, int, int, cuDoubleComplex *,
+ int, const cuDoubleComplex *, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungbr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, m, n, k, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsytrd_bufferSize(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const float *A,
+ int lda, const float *d, const float *e, const float *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, const float *, int,
+ const float *, const float *, const float *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsytrd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, d, e, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsytrd_bufferSize(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const double *A,
+ int lda, const double *d, const double *e, const double *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, const double *, int,
+ const double *, const double *, const double *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsytrd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, d, e, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnChetrd_bufferSize(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const cuComplex *A,
+ int lda, const float *d, const float *e, const cuComplex *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, const cuComplex *, int,
+ const float *, const float *, const cuComplex *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChetrd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, d, e, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZhetrd_bufferSize(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
+ const cuDoubleComplex *A, int lda, const double *d, const double *e,
+ const cuDoubleComplex *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, int,
+ const double *, const double *, const cuDoubleComplex *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhetrd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, d, e, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsytrd(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ float *A, int lda, float *d,
+ float *e, float *tau, float *work,
+ int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, float *, int, float *, float *,
+ float *, float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsytrd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, d, e, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsytrd(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, double *A, int lda,
+ double *d, double *e, double *tau, double *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, double *, int, double *,
+ double *, double *, double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsytrd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, d, e, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnChetrd(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ cuComplex *A, int lda, float *d,
+ float *e, cuComplex *tau,
+ cuComplex *work, int lwork,
+ int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, cuComplex *, int, float *,
+ float *, cuComplex *, cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChetrd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, d, e, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZhetrd(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, cuDoubleComplex *A,
+ int lda, double *d, double *e, cuDoubleComplex *tau, cuDoubleComplex *work,
+ int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, cuDoubleComplex *, int,
+ double *, double *, cuDoubleComplex *, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhetrd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, d, e, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSorgtr_bufferSize(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const float *A,
+ int lda, const float *tau, int *lwork) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
+ const float *, int, const float *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgtr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDorgtr_bufferSize(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const double *A,
+ int lda, const double *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, const double *, int,
+ const double *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgtr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCungtr_bufferSize(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const cuComplex *A,
+ int lda, const cuComplex *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, const cuComplex *, int,
+ const cuComplex *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungtr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZungtr_bufferSize(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
+ const cuDoubleComplex *A, int lda, const cuDoubleComplex *tau, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, int,
+ const cuDoubleComplex *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungtr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, tau, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSorgtr(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ float *A, int lda,
+ const float *tau, float *work,
+ int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, float *, int, const float *,
+ float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgtr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDorgtr(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ double *A, int lda,
+ const double *tau, double *work,
+ int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, double *, int, const double *,
+ double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgtr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCungtr(
+ cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, cuComplex *A,
+ int lda, const cuComplex *tau, cuComplex *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, cuComplex *, int,
+ const cuComplex *, cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungtr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZungtr(cusolverDnHandle_t handle,
+ cublasFillMode_t uplo, int n,
+ cuDoubleComplex *A, int lda,
+ const cuDoubleComplex *tau,
+ cuDoubleComplex *work, int lwork,
+ int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasFillMode_t, int, cuDoubleComplex *, int,
+ const cuDoubleComplex *, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungtr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, uplo, n, A, lda, tau, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSormtr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
+ cublasOperation_t trans, int m, int n, const float *A, int lda,
+ const float *tau, const float *C, int ldc, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
+ int, int, const float *, int, const float *, const float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSormtr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDormtr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
+ cublasOperation_t trans, int m, int n, const double *A, int lda,
+ const double *tau, const double *C, int ldc, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
+ int, int, const double *, int, const double *, const double *, int,
+ int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDormtr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCunmtr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
+ cublasOperation_t trans, int m, int n, const cuComplex *A, int lda,
+ const cuComplex *tau, const cuComplex *C, int ldc, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
+ int, int, const cuComplex *, int, const cuComplex *, const cuComplex *,
+ int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCunmtr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZunmtr_bufferSize(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
+ cublasOperation_t trans, int m, int n, const cuDoubleComplex *A, int lda,
+ const cuDoubleComplex *tau, const cuDoubleComplex *C, int ldc, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
+ int, int, const cuDoubleComplex *, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZunmtr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSormtr(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
+ cublasOperation_t trans, int m, int n, float *A, int lda, float *tau,
+ float *C, int ldc, float *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
+ int, int, float *, int, float *, float *, int, float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSormtr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work,
+ lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDormtr(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
+ cublasOperation_t trans, int m, int n, double *A, int lda, double *tau,
+ double *C, int ldc, double *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
+ int, int, double *, int, double *, double *, int, double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDormtr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work,
+ lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnCunmtr(cusolverDnHandle_t handle, cublasSideMode_t side,
+ cublasFillMode_t uplo, cublasOperation_t trans, int m, int n,
+ cuComplex *A, int lda, cuComplex *tau, cuComplex *C, int ldc,
+ cuComplex *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
+ int, int, cuComplex *, int, cuComplex *, cuComplex *, int, cuComplex *,
+ int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCunmtr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work,
+ lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZunmtr(
+ cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
+ cublasOperation_t trans, int m, int n, cuDoubleComplex *A, int lda,
+ cuDoubleComplex *tau, cuDoubleComplex *C, int ldc, cuDoubleComplex *work,
+ int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
+ int, int, cuDoubleComplex *, int, cuDoubleComplex *, cuDoubleComplex *,
+ int, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZunmtr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work,
+ lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgesvd_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int *lwork) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgesvd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgesvd_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int *lwork) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgesvd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCgesvd_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int *lwork) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgesvd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZgesvd_bufferSize(
+ cusolverDnHandle_t handle, int m, int n, int *lwork) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgesvd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgesvd(
+ cusolverDnHandle_t handle, signed char jobu, signed char jobvt, int m,
+ int n, float *A, int lda, float *S, float *U, int ldu, float *VT, int ldvt,
+ float *work, int lwork, float *rwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, signed char, signed char, int, int, float *, int,
+ float *, float *, int, float *, int, float *, int, float *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgesvd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, work,
+ lwork, rwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgesvd(
+ cusolverDnHandle_t handle, signed char jobu, signed char jobvt, int m,
+ int n, double *A, int lda, double *S, double *U, int ldu, double *VT,
+ int ldvt, double *work, int lwork, double *rwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, signed char, signed char, int, int, double *, int,
+ double *, double *, int, double *, int, double *, int, double *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgesvd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, work,
+ lwork, rwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnCgesvd(cusolverDnHandle_t handle, signed char jobu, signed char jobvt,
+ int m, int n, cuComplex *A, int lda, float *S, cuComplex *U,
+ int ldu, cuComplex *VT, int ldvt, cuComplex *work, int lwork,
+ float *rwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, signed char, signed char, int, int, cuComplex *, int,
+ float *, cuComplex *, int, cuComplex *, int, cuComplex *, int, float *,
+ int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgesvd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, work,
+ lwork, rwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnZgesvd(cusolverDnHandle_t handle, signed char jobu, signed char jobvt,
+ int m, int n, cuDoubleComplex *A, int lda, double *S,
+ cuDoubleComplex *U, int ldu, cuDoubleComplex *VT, int ldvt,
+ cuDoubleComplex *work, int lwork, double *rwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, signed char, signed char, int, int, cuDoubleComplex *,
+ int, double *, cuDoubleComplex *, int, cuDoubleComplex *, int,
+ cuDoubleComplex *, int, double *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgesvd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, work,
+ lwork, rwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsyevd_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const float *A, int lda, const float *W, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const float *, int, const float *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsyevd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsyevd_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const double *A, int lda, const double *W, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const double *, int, const double *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsyevd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCheevd_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const cuComplex *A, int lda, const float *W, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const cuComplex *, int, const float *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCheevd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZheevd_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const cuDoubleComplex *A, int lda, const double *W, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const cuDoubleComplex *, int, const double *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZheevd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsyevd(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, float *A, int lda, float *W, float *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, float *,
+ int, float *, float *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsyevd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsyevd(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, double *A, int lda, double *W, double *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, double *,
+ int, double *, double *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsyevd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCheevd(cusolverDnHandle_t handle,
+ cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n,
+ cuComplex *A, int lda, float *W,
+ cuComplex *work, int lwork,
+ int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, cuComplex *,
+ int, float *, cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCheevd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZheevd(cusolverDnHandle_t handle,
+ cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n,
+ cuDoubleComplex *A, int lda,
+ double *W, cuDoubleComplex *work,
+ int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ cuDoubleComplex *, int, double *, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZheevd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsygvd_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, const float *A, int lda, const float *B,
+ int ldb, const float *W, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, const float *, int, const float *, int,
+ const float *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsygvd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsygvd_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, const double *A, int lda, const double *B,
+ int ldb, const double *W, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, const double *, int, const double *, int,
+ const double *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsygvd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnChegvd_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, const cuComplex *A, int lda,
+ const cuComplex *B, int ldb, const float *W, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, const cuComplex *, int, const cuComplex *, int,
+ const float *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChegvd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZhegvd_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, const cuDoubleComplex *A, int lda,
+ const cuDoubleComplex *B, int ldb, const double *W, int *lwork) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, const cuDoubleComplex *, int,
+ const cuDoubleComplex *, int, const double *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhegvd_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsygvd(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, float *A, int lda, float *B, int ldb,
+ float *W, float *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, float *, int, float *, int, float *, float *, int,
+ int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsygvd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
+ info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsygvd(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, double *A, int lda, double *B, int ldb,
+ double *W, double *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, double *, int, double *, int, double *, double *,
+ int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsygvd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
+ info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnChegvd(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, cuComplex *A, int lda, cuComplex *B, int ldb,
+ float *W, cuComplex *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, cuComplex *, int, cuComplex *, int, float *,
+ cuComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChegvd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
+ info);
+}
+
+cusolverStatus_t CUSOLVERAPI
+cusolverDnZhegvd(cusolverDnHandle_t handle, cusolverEigType_t itype,
+ cusolverEigMode_t jobz, cublasFillMode_t uplo, int n,
+ cuDoubleComplex *A, int lda, cuDoubleComplex *B, int ldb,
+ double *W, cuDoubleComplex *work, int lwork, int *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, cuDoubleComplex *, int, cuDoubleComplex *, int,
+ double *, cuDoubleComplex *, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhegvd");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
+ info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCreateSyevjInfo(syevjInfo_t *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(syevjInfo_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCreateSyevjInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDestroySyevjInfo(syevjInfo_t info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDestroySyevjInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnXsyevjSetTolerance(syevjInfo_t info,
+ double tolerance) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(syevjInfo_t, double);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXsyevjSetTolerance");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info, tolerance);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnXsyevjSetMaxSweeps(syevjInfo_t info,
+ int max_sweeps) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(syevjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXsyevjSetMaxSweeps");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info, max_sweeps);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnXsyevjSetSortEig(syevjInfo_t info,
+ int sort_eig) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(syevjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXsyevjSetSortEig");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info, sort_eig);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnXsyevjGetResidual(
+ cusolverDnHandle_t handle, syevjInfo_t info, double *residual) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t,
+ syevjInfo_t, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXsyevjGetResidual");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, residual);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnXsyevjGetSweeps(
+ cusolverDnHandle_t handle, syevjInfo_t info, int *executed_sweeps) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, syevjInfo_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXsyevjGetSweeps");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, executed_sweeps);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsyevjBatched_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const float *A, int lda, const float *W, int *lwork,
+ syevjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const float *, int, const float *, int *, syevjInfo_t, int);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusolverDnSsyevjBatched_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsyevjBatched_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const double *A, int lda, const double *W, int *lwork,
+ syevjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const double *, int, const double *, int *, syevjInfo_t, int);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusolverDnDsyevjBatched_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCheevjBatched_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const cuComplex *A, int lda, const float *W, int *lwork,
+ syevjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const cuComplex *, int, const float *, int *, syevjInfo_t, int);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusolverDnCheevjBatched_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZheevjBatched_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const cuDoubleComplex *A, int lda, const double *W, int *lwork,
+ syevjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const cuDoubleComplex *, int, const double *, int *, syevjInfo_t, int);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusolverDnZheevjBatched_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsyevjBatched(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, float *A, int lda, float *W, float *work, int lwork, int *info,
+ syevjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, float *,
+ int, float *, float *, int, int *, syevjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsyevjBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params,
+ batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsyevjBatched(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, double *A, int lda, double *W, double *work, int lwork, int *info,
+ syevjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, double *,
+ int, double *, double *, int, int *, syevjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsyevjBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params,
+ batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCheevjBatched(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, cuComplex *A, int lda, float *W, cuComplex *work, int lwork,
+ int *info, syevjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, cuComplex *,
+ int, float *, cuComplex *, int, int *, syevjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCheevjBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params,
+ batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZheevjBatched(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, cuDoubleComplex *A, int lda, double *W, cuDoubleComplex *work,
+ int lwork, int *info, syevjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ cuDoubleComplex *, int, double *, cuDoubleComplex *, int, int *,
+ syevjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZheevjBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params,
+ batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsyevj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const float *A, int lda, const float *W, int *lwork,
+ syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const float *, int, const float *, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsyevj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsyevj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const double *A, int lda, const double *W, int *lwork,
+ syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const double *, int, const double *, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsyevj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCheevj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const cuComplex *A, int lda, const float *W, int *lwork,
+ syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const cuComplex *, int, const float *, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCheevj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZheevj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, const cuDoubleComplex *A, int lda, const double *W, int *lwork,
+ syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ const cuDoubleComplex *, int, const double *, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZheevj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsyevj(cusolverDnHandle_t handle,
+ cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n,
+ float *A, int lda, float *W,
+ float *work, int lwork, int *info,
+ syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, float *,
+ int, float *, float *, int, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsyevj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsyevj(cusolverDnHandle_t handle,
+ cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n,
+ double *A, int lda, double *W,
+ double *work, int lwork,
+ int *info, syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, double *,
+ int, double *, double *, int, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsyevj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCheevj(cusolverDnHandle_t handle,
+ cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n,
+ cuComplex *A, int lda, float *W,
+ cuComplex *work, int lwork,
+ int *info, syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, cuComplex *,
+ int, float *, cuComplex *, int, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCheevj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZheevj(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
+ int n, cuDoubleComplex *A, int lda, double *W, cuDoubleComplex *work,
+ int lwork, int *info, syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
+ cuDoubleComplex *, int, double *, cuDoubleComplex *, int, int *,
+ syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZheevj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsygvj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, const float *A, int lda, const float *B,
+ int ldb, const float *W, int *lwork, syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, const float *, int, const float *, int,
+ const float *, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsygvj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork,
+ params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsygvj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, const double *A, int lda, const double *B,
+ int ldb, const double *W, int *lwork, syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, const double *, int, const double *, int,
+ const double *, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsygvj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork,
+ params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnChegvj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, const cuComplex *A, int lda,
+ const cuComplex *B, int ldb, const float *W, int *lwork,
+ syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, const cuComplex *, int, const cuComplex *, int,
+ const float *, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChegvj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork,
+ params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZhegvj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, const cuDoubleComplex *A, int lda,
+ const cuDoubleComplex *B, int ldb, const double *W, int *lwork,
+ syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, const cuDoubleComplex *, int,
+ const cuDoubleComplex *, int, const double *, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhegvj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork,
+ params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSsygvj(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, float *A, int lda, float *B, int ldb,
+ float *W, float *work, int lwork, int *info, syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, float *, int, float *, int, float *, float *, int,
+ int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsygvj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
+ info, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDsygvj(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, double *A, int lda, double *B, int ldb,
+ double *W, double *work, int lwork, int *info, syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, double *, int, double *, int, double *, double *,
+ int, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsygvj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
+ info, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnChegvj(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, cuComplex *A, int lda, cuComplex *B, int ldb,
+ float *W, cuComplex *work, int lwork, int *info, syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, cuComplex *, int, cuComplex *, int, float *,
+ cuComplex *, int, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChegvj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
+ info, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZhegvj(
+ cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
+ cublasFillMode_t uplo, int n, cuDoubleComplex *A, int lda,
+ cuDoubleComplex *B, int ldb, double *W, cuDoubleComplex *work, int lwork,
+ int *info, syevjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
+ cublasFillMode_t, int, cuDoubleComplex *, int, cuDoubleComplex *, int,
+ double *, cuDoubleComplex *, int, int *, syevjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhegvj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
+ info, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCreateGesvdjInfo(gesvdjInfo_t *info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(gesvdjInfo_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCreateGesvdjInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDestroyGesvdjInfo(gesvdjInfo_t info) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(gesvdjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDestroyGesvdjInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnXgesvdjSetTolerance(gesvdjInfo_t info,
+ double tolerance) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(gesvdjInfo_t, double);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXgesvdjSetTolerance");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info, tolerance);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnXgesvdjSetMaxSweeps(gesvdjInfo_t info,
+ int max_sweeps) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(gesvdjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXgesvdjSetMaxSweeps");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info, max_sweeps);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnXgesvdjSetSortEig(gesvdjInfo_t info,
+ int sort_svd) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(gesvdjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXgesvdjSetSortEig");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info, sort_svd);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnXgesvdjGetResidual(
+ cusolverDnHandle_t handle, gesvdjInfo_t info, double *residual) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t,
+ gesvdjInfo_t, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXgesvdjGetResidual");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, residual);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnXgesvdjGetSweeps(
+ cusolverDnHandle_t handle, gesvdjInfo_t info, int *executed_sweeps) {
+ using FuncPtr =
+ cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, gesvdjInfo_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXgesvdjGetSweeps");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, executed_sweeps);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgesvdjBatched_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
+ const float *A, int lda, const float *S, const float *U, int ldu,
+ const float *V, int ldv, int *lwork, gesvdjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, const float *, int,
+ const float *, const float *, int, const float *, int, int *,
+ gesvdjInfo_t, int);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusolverDnSgesvdjBatched_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, lwork, params,
+ batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgesvdjBatched_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
+ const double *A, int lda, const double *S, const double *U, int ldu,
+ const double *V, int ldv, int *lwork, gesvdjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, const double *, int,
+ const double *, const double *, int, const double *, int, int *,
+ gesvdjInfo_t, int);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusolverDnDgesvdjBatched_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, lwork, params,
+ batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCgesvdjBatched_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
+ const cuComplex *A, int lda, const float *S, const cuComplex *U, int ldu,
+ const cuComplex *V, int ldv, int *lwork, gesvdjInfo_t params,
+ int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, const cuComplex *, int,
+ const float *, const cuComplex *, int, const cuComplex *, int, int *,
+ gesvdjInfo_t, int);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusolverDnCgesvdjBatched_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, lwork, params,
+ batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZgesvdjBatched_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
+ const cuDoubleComplex *A, int lda, const double *S,
+ const cuDoubleComplex *U, int ldu, const cuDoubleComplex *V, int ldv,
+ int *lwork, gesvdjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, const cuDoubleComplex *,
+ int, const double *, const cuDoubleComplex *, int,
+ const cuDoubleComplex *, int, int *, gesvdjInfo_t, int);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusolverDnZgesvdjBatched_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, lwork, params,
+ batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgesvdjBatched(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n, float *A,
+ int lda, float *S, float *U, int ldu, float *V, int ldv, float *work,
+ int lwork, int *info, gesvdjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, float *, int, float *,
+ float *, int, float *, int, float *, int, int *, gesvdjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgesvdjBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, work, lwork,
+ info, params, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgesvdjBatched(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n, double *A,
+ int lda, double *S, double *U, int ldu, double *V, int ldv, double *work,
+ int lwork, int *info, gesvdjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, double *, int, double *,
+ double *, int, double *, int, double *, int, int *, gesvdjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgesvdjBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, work, lwork,
+ info, params, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCgesvdjBatched(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
+ cuComplex *A, int lda, float *S, cuComplex *U, int ldu, cuComplex *V,
+ int ldv, cuComplex *work, int lwork, int *info, gesvdjInfo_t params,
+ int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, cuComplex *, int,
+ float *, cuComplex *, int, cuComplex *, int, cuComplex *, int, int *,
+ gesvdjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgesvdjBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, work, lwork,
+ info, params, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZgesvdjBatched(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
+ cuDoubleComplex *A, int lda, double *S, cuDoubleComplex *U, int ldu,
+ cuDoubleComplex *V, int ldv, cuDoubleComplex *work, int lwork, int *info,
+ gesvdjInfo_t params, int batchSize) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, cuDoubleComplex *, int,
+ double *, cuDoubleComplex *, int, cuDoubleComplex *, int,
+ cuDoubleComplex *, int, int *, gesvdjInfo_t, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgesvdjBatched");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, work, lwork,
+ info, params, batchSize);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgesvdj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
+ const float *A, int lda, const float *S, const float *U, int ldu,
+ const float *V, int ldv, int *lwork, gesvdjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, int, const float *, int,
+ const float *, const float *, int, const float *, int, int *,
+ gesvdjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgesvdj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, lwork,
+ params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgesvdj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
+ const double *A, int lda, const double *S, const double *U, int ldu,
+ const double *V, int ldv, int *lwork, gesvdjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, int, const double *, int,
+ const double *, const double *, int, const double *, int, int *,
+ gesvdjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgesvdj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, lwork,
+ params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCgesvdj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
+ const cuComplex *A, int lda, const float *S, const cuComplex *U, int ldu,
+ const cuComplex *V, int ldv, int *lwork, gesvdjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, int, const cuComplex *,
+ int, const float *, const cuComplex *, int, const cuComplex *, int, int *,
+ gesvdjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgesvdj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, lwork,
+ params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZgesvdj_bufferSize(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
+ const cuDoubleComplex *A, int lda, const double *S,
+ const cuDoubleComplex *U, int ldu, const cuDoubleComplex *V, int ldv,
+ int *lwork, gesvdjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, int,
+ const cuDoubleComplex *, int, const double *, const cuDoubleComplex *,
+ int, const cuDoubleComplex *, int, int *, gesvdjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgesvdj_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, lwork,
+ params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnSgesvdj(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
+ float *A, int lda, float *S, float *U, int ldu, float *V, int ldv,
+ float *work, int lwork, int *info, gesvdjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, int, float *, int,
+ float *, float *, int, float *, int, float *, int, int *, gesvdjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgesvdj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, work,
+ lwork, info, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnDgesvdj(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
+ double *A, int lda, double *S, double *U, int ldu, double *V, int ldv,
+ double *work, int lwork, int *info, gesvdjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, int, double *, int,
+ double *, double *, int, double *, int, double *, int, int *,
+ gesvdjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgesvdj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, work,
+ lwork, info, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnCgesvdj(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
+ cuComplex *A, int lda, float *S, cuComplex *U, int ldu, cuComplex *V,
+ int ldv, cuComplex *work, int lwork, int *info, gesvdjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, int, cuComplex *, int,
+ float *, cuComplex *, int, cuComplex *, int, cuComplex *, int, int *,
+ gesvdjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgesvdj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, work,
+ lwork, info, params);
+}
+
+cusolverStatus_t CUSOLVERAPI cusolverDnZgesvdj(
+ cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
+ cuDoubleComplex *A, int lda, double *S, cuDoubleComplex *U, int ldu,
+ cuDoubleComplex *V, int ldv, cuDoubleComplex *work, int lwork, int *info,
+ gesvdjInfo_t params) {
+ using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
+ cusolverDnHandle_t, cusolverEigMode_t, int, int, int, cuDoubleComplex *,
+ int, double *, cuDoubleComplex *, int, cuDoubleComplex *, int,
+ cuDoubleComplex *, int, int *, gesvdjInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgesvdj");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, work,
+ lwork, info, params);
+}
+
+} // extern "C"
diff --git a/tensorflow/stream_executor/cuda/cusolver_stub.cc b/tensorflow/stream_executor/cuda/cusolver_stub.cc
new file mode 100644
index 00000000000..664d10dcc64
--- /dev/null
+++ b/tensorflow/stream_executor/cuda/cusolver_stub.cc
@@ -0,0 +1,53 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#include "cuda/include/cusolverDn.h"
+#include "tensorflow/stream_executor/lib/env.h"
+#include "tensorflow/stream_executor/platform/dso_loader.h"
+
+// Implements the cusolver API by forwarding to cusolver loaded from the DSO.
+
+namespace {
+// Returns DSO handle or null if loading the DSO fails.
+void* GetDsoHandle() {
+#ifdef PLATFORM_GOOGLE
+ return nullptr;
+#else
+ static auto handle = []() -> void* {
+ auto handle_or =
+ stream_executor::internal::DsoLoader::GetCusolverDsoHandle();
+ if (!handle_or.ok()) return nullptr;
+ return handle_or.ValueOrDie();
+ }();
+ return handle;
+#endif
+}
+
+template <typename T>
+T LoadSymbol(const char* symbol_name) {
+ void* symbol = nullptr;
+ if (auto handle = GetDsoHandle()) {
+ stream_executor::port::Env::Default()
+ ->GetSymbolFromLibrary(handle, symbol_name, &symbol)
+ .IgnoreError();
+ }
+ return reinterpret_cast<T>(symbol);
+}
+
+cusolverStatus_t GetSymbolNotFoundError() {
+ return CUSOLVER_STATUS_INTERNAL_ERROR;
+}
+} // namespace
+
+#include "tensorflow/stream_executor/cuda/cusolver_dense_10_0.inc"
diff --git a/tensorflow/stream_executor/cuda/cusparse_10_0.inc b/tensorflow/stream_executor/cuda/cusparse_10_0.inc
new file mode 100644
index 00000000000..54df292f883
--- /dev/null
+++ b/tensorflow/stream_executor/cuda/cusparse_10_0.inc
@@ -0,0 +1,7800 @@
+// Auto-generated, do not edit.
+
+extern "C" {
+
+cusparseStatus_t CUSPARSEAPI cusparseCreate(cusparseHandle_t *handle) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreate");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroy(cusparseHandle_t handle) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroy");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseGetVersion(cusparseHandle_t handle,
+ int *version) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetVersion");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, version);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseGetProperty(libraryPropertyType type,
+ int *value) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(libraryPropertyType, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetProperty");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(type, value);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSetStream(cusparseHandle_t handle,
+ cudaStream_t streamId) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, cudaStream_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetStream");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, streamId);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseGetStream(cusparseHandle_t handle,
+ cudaStream_t *streamId) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, cudaStream_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetStream");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, streamId);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseGetPointerMode(cusparseHandle_t handle, cusparsePointerMode_t *mode) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t,
+ cusparsePointerMode_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetPointerMode");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mode);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSetPointerMode(cusparseHandle_t handle, cusparsePointerMode_t mode) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, cusparsePointerMode_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetPointerMode");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mode);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCreateMatDescr(cusparseMatDescr_t *descrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateMatDescr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDestroyMatDescr(cusparseMatDescr_t descrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyMatDescr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCopyMatDescr(cusparseMatDescr_t dest, const cusparseMatDescr_t src) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t,
+ const cusparseMatDescr_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCopyMatDescr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(dest, src);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSetMatType(cusparseMatDescr_t descrA,
+ cusparseMatrixType_t type) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseMatrixType_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatType");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA, type);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSetMatFillMode(cusparseMatDescr_t descrA, cusparseFillMode_t fillMode) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseFillMode_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatFillMode");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA, fillMode);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSetMatDiagType(cusparseMatDescr_t descrA, cusparseDiagType_t diagType) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseDiagType_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatDiagType");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA, diagType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSetMatIndexBase(cusparseMatDescr_t descrA,
+ cusparseIndexBase_t base) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatIndexBase");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA, base);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCreateSolveAnalysisInfo(cusparseSolveAnalysisInfo_t *info) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseSolveAnalysisInfo_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateSolveAnalysisInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDestroySolveAnalysisInfo(cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSolveAnalysisInfo_t);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDestroySolveAnalysisInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseGetLevelInfo(cusparseHandle_t handle, cusparseSolveAnalysisInfo_t info,
+ int *nlevels, int **levelPtr, int **levelInd) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseSolveAnalysisInfo_t, int *, int **, int **);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetLevelInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, nlevels, levelPtr, levelInd);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateCsrsv2Info(csrsv2Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrsv2Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsrsv2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrsv2Info(csrsv2Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrsv2Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsrsv2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateCsric02Info(csric02Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csric02Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsric02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyCsric02Info(csric02Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csric02Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsric02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateBsric02Info(bsric02Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsric02Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsric02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyBsric02Info(bsric02Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsric02Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsric02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateCsrilu02Info(csrilu02Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrilu02Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsrilu02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrilu02Info(csrilu02Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrilu02Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsrilu02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateBsrilu02Info(bsrilu02Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrilu02Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsrilu02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrilu02Info(bsrilu02Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrilu02Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsrilu02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateBsrsv2Info(bsrsv2Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsv2Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsrsv2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrsv2Info(bsrsv2Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsv2Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsrsv2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateBsrsm2Info(bsrsm2Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsm2Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsrsm2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrsm2Info(bsrsm2Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsm2Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsrsm2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateHybMat(cusparseHybMat_t *hybA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHybMat_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateHybMat");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(hybA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyHybMat(cusparseHybMat_t hybA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHybMat_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyHybMat");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(hybA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateCsru2csrInfo(csru2csrInfo_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csru2csrInfo_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsru2csrInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyCsru2csrInfo(csru2csrInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csru2csrInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsru2csrInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCreateColorInfo(cusparseColorInfo_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateColorInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDestroyColorInfo(cusparseColorInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyColorInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSetColorAlgs(cusparseColorInfo_t info,
+ cusparseColorAlg_t alg) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t, cusparseColorAlg_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetColorAlgs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info, alg);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseGetColorAlgs(cusparseColorInfo_t info,
+ cusparseColorAlg_t *alg) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t,
+ cusparseColorAlg_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetColorAlgs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info, alg);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreatePruneInfo(pruneInfo_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(pruneInfo_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreatePruneInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyPruneInfo(pruneInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(pruneInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyPruneInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSaxpyi(cusparseHandle_t handle, int nnz,
+ const float *alpha,
+ const float *xVal, const int *xInd,
+ float *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, const float *, const int *, float *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSaxpyi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDaxpyi(cusparseHandle_t handle, int nnz,
+ const double *alpha,
+ const double *xVal, const int *xInd,
+ double *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const double *, const int *,
+ double *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDaxpyi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCaxpyi(cusparseHandle_t handle, int nnz,
+ const cuComplex *alpha,
+ const cuComplex *xVal,
+ const int *xInd, cuComplex *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const cuComplex *, const int *,
+ cuComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCaxpyi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZaxpyi(cusparseHandle_t handle, int nnz,
+ const cuDoubleComplex *alpha,
+ const cuDoubleComplex *xVal,
+ const int *xInd, cuDoubleComplex *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
+ const int *, cuDoubleComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZaxpyi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSdoti(cusparseHandle_t handle, int nnz,
+ const float *xVal, const int *xInd,
+ const float *y,
+ float *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, const int *, const float *, float *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSdoti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDdoti(cusparseHandle_t handle, int nnz,
+ const double *xVal, const int *xInd,
+ const double *y,
+ double *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const int *, const double *,
+ double *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDdoti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCdoti(cusparseHandle_t handle, int nnz,
+ const cuComplex *xVal,
+ const int *xInd, const cuComplex *y,
+ cuComplex *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const int *, const cuComplex *,
+ cuComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdoti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZdoti(cusparseHandle_t handle, int nnz,
+ const cuDoubleComplex *xVal,
+ const int *xInd,
+ const cuDoubleComplex *y,
+ cuDoubleComplex *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const int *,
+ const cuDoubleComplex *, cuDoubleComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdoti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCdotci(cusparseHandle_t handle, int nnz,
+ const cuComplex *xVal,
+ const int *xInd, const cuComplex *y,
+ cuComplex *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const int *, const cuComplex *,
+ cuComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdotci");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZdotci(cusparseHandle_t handle, int nnz,
+ const cuDoubleComplex *xVal,
+ const int *xInd,
+ const cuDoubleComplex *y,
+ cuDoubleComplex *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const int *,
+ const cuDoubleComplex *, cuDoubleComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdotci");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgthr(cusparseHandle_t handle, int nnz,
+ const float *y, float *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, float *, const int *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgthr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgthr(cusparseHandle_t handle, int nnz,
+ const double *y, double *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, double *, const int *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgthr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgthr(cusparseHandle_t handle, int nnz,
+ const cuComplex *y, cuComplex *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, cuComplex *, const int *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgthr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgthr(cusparseHandle_t handle, int nnz,
+ const cuDoubleComplex *y,
+ cuDoubleComplex *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, cuDoubleComplex *,
+ const int *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgthr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgthrz(cusparseHandle_t handle, int nnz,
+ float *y, float *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, float *, float *,
+ const int *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgthrz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgthrz(cusparseHandle_t handle, int nnz,
+ double *y, double *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, double *, double *,
+ const int *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgthrz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgthrz(cusparseHandle_t handle, int nnz,
+ cuComplex *y, cuComplex *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cuComplex *, cuComplex *, const int *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgthrz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgthrz(cusparseHandle_t handle, int nnz,
+ cuDoubleComplex *y,
+ cuDoubleComplex *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cuDoubleComplex *, cuDoubleComplex *, const int *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgthrz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSsctr(cusparseHandle_t handle, int nnz,
+ const float *xVal, const int *xInd,
+ float *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int,
+ const float *, const int *,
+ float *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSsctr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDsctr(cusparseHandle_t handle, int nnz,
+ const double *xVal, const int *xInd,
+ double *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const int *, double *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDsctr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsctr(cusparseHandle_t handle, int nnz,
+ const cuComplex *xVal,
+ const int *xInd, cuComplex *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const int *, cuComplex *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsctr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZsctr(cusparseHandle_t handle, int nnz,
+ const cuDoubleComplex *xVal,
+ const int *xInd, cuDoubleComplex *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const int *,
+ cuDoubleComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZsctr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSroti(cusparseHandle_t handle, int nnz,
+ float *xVal, const int *xInd,
+ float *y, const float *c,
+ const float *s,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, float *, const int *, float *, const float *,
+ const float *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSroti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, c, s, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDroti(cusparseHandle_t handle, int nnz,
+ double *xVal, const int *xInd,
+ double *y, const double *c,
+ const double *s,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, double *, const int *, double *, const double *,
+ const double *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDroti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, c, s, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSgemvi(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, const float *alpha, /* host or device pointer */
+ const float *A, int lda, int nnz, const float *xVal,
+ const int *xInd, const float *beta, /* host or device pointer */
+ float *y, cusparseIndexBase_t idxBase, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const float *,
+ const float *, int, int, const float *, const int *, const float *,
+ float *, cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgemvi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
+ idxBase, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
+ int m, int n, int nnz, int *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgemvi_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDgemvi(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, const double *alpha, /* host or device pointer */
+ const double *A, int lda, int nnz, const double *xVal,
+ const int *xInd, const double *beta, /* host or device pointer */
+ double *y, cusparseIndexBase_t idxBase, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const double *,
+ const double *, int, int, const double *, const int *, const double *,
+ double *, cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgemvi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
+ idxBase, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
+ int m, int n, int nnz, int *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgemvi_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgemvi(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const cuComplex *alpha, /* host or device pointer */
+ const cuComplex *A, int lda, int nnz, const cuComplex *xVal,
+ const int *xInd, const cuComplex *beta, /* host or device pointer */
+ cuComplex *y, cusparseIndexBase_t idxBase, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuComplex *,
+ const cuComplex *, int, int, const cuComplex *, const int *,
+ const cuComplex *, cuComplex *, cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgemvi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
+ idxBase, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
+ int m, int n, int nnz, int *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgemvi_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgemvi(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const cuDoubleComplex *alpha, /* host or device pointer */
+ const cuDoubleComplex *A, int lda, int nnz, const cuDoubleComplex *xVal,
+ const int *xInd, const cuDoubleComplex *beta, /* host or device pointer */
+ cuDoubleComplex *y, cusparseIndexBase_t idxBase, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, int, int, const cuDoubleComplex *, const int *,
+ const cuDoubleComplex *, cuDoubleComplex *, cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgemvi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
+ idxBase, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
+ int m, int n, int nnz, int *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgemvi_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrmv(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int nnz,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *x, const float *beta, float *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ const float *, const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDcsrmv(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, int nnz, const double *alpha,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const double *x, const double *beta, double *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ const double *, const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCcsrmv(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, int nnz, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cuComplex *x, const cuComplex *beta, cuComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ const cuComplex *, const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrmv(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int nnz,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *x,
+ const cuDoubleComplex *beta, cuDoubleComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int,
+ const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsrmvEx_bufferSize(
+ cusparseHandle_t handle, cusparseAlgMode_t alg, cusparseOperation_t transA,
+ int m, int n, int nnz, const void *alpha, cudaDataType alphatype,
+ const cusparseMatDescr_t descrA, const void *csrValA,
+ cudaDataType csrValAtype, const int *csrRowPtrA, const int *csrColIndA,
+ const void *x, cudaDataType xtype, const void *beta, cudaDataType betatype,
+ void *y, cudaDataType ytype, cudaDataType executiontype,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseAlgMode_t, cusparseOperation_t, int, int, int,
+ const void *, cudaDataType, const cusparseMatDescr_t, const void *,
+ cudaDataType, const int *, const int *, const void *, cudaDataType,
+ const void *, cudaDataType, void *, cudaDataType, cudaDataType, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrmvEx_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, alg, transA, m, n, nnz, alpha, alphatype, descrA,
+ csrValA, csrValAtype, csrRowPtrA, csrColIndA, x, xtype, beta,
+ betatype, y, ytype, executiontype, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsrmvEx(
+ cusparseHandle_t handle, cusparseAlgMode_t alg, cusparseOperation_t transA,
+ int m, int n, int nnz, const void *alpha, cudaDataType alphatype,
+ const cusparseMatDescr_t descrA, const void *csrValA,
+ cudaDataType csrValAtype, const int *csrRowPtrA, const int *csrColIndA,
+ const void *x, cudaDataType xtype, const void *beta, cudaDataType betatype,
+ void *y, cudaDataType ytype, cudaDataType executiontype, void *buffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseAlgMode_t, cusparseOperation_t, int, int, int,
+ const void *, cudaDataType, const cusparseMatDescr_t, const void *,
+ cudaDataType, const int *, const int *, const void *, cudaDataType,
+ const void *, cudaDataType, void *, cudaDataType, cudaDataType, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrmvEx");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, alg, transA, m, n, nnz, alpha, alphatype, descrA,
+ csrValA, csrValAtype, csrRowPtrA, csrColIndA, x, xtype, beta,
+ betatype, y, ytype, executiontype, buffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrmv_mp(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int nnz,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *x, const float *beta, float *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ const float *, const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrmv_mp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDcsrmv_mp(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, int nnz, const double *alpha,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const double *x, const double *beta, double *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ const double *, const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrmv_mp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrmv_mp(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int nnz,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuComplex *x, const cuComplex *beta,
+ cuComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ const cuComplex *, const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrmv_mp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrmv_mp(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int nnz,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *x,
+ const cuDoubleComplex *beta, cuDoubleComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int,
+ const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrmv_mp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseShybmv(
+ cusparseHandle_t handle, cusparseOperation_t transA, const float *alpha,
+ const cusparseMatDescr_t descrA, const cusparseHybMat_t hybA,
+ const float *x, const float *beta, float *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const float *,
+ const cusparseMatDescr_t, const cusparseHybMat_t, const float *,
+ const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShybmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, alpha, descrA, hybA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDhybmv(
+ cusparseHandle_t handle, cusparseOperation_t transA, const double *alpha,
+ const cusparseMatDescr_t descrA, const cusparseHybMat_t hybA,
+ const double *x, const double *beta, double *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const double *,
+ const cusparseMatDescr_t, const cusparseHybMat_t, const double *,
+ const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhybmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, alpha, descrA, hybA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseChybmv(
+ cusparseHandle_t handle, cusparseOperation_t transA, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, const cusparseHybMat_t hybA,
+ const cuComplex *x, const cuComplex *beta, cuComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cuComplex *,
+ const cusparseMatDescr_t, const cusparseHybMat_t, const cuComplex *,
+ const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChybmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, alpha, descrA, hybA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZhybmv(cusparseHandle_t handle, cusparseOperation_t transA,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA, const cuDoubleComplex *x,
+ const cuDoubleComplex *beta, cuDoubleComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cusparseHybMat_t, const cuDoubleComplex *,
+ const cuDoubleComplex *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhybmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, alpha, descrA, hybA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrmv(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nb, int nnzb, const float *alpha,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const float *x, const float *beta, float *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ const float *, const cusparseMatDescr_t, const float *, const int *,
+ const int *, int, const float *, const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
+ x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrmv(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nb, int nnzb, const double *alpha,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const double *x, const double *beta, double *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ const double *, const cusparseMatDescr_t, const double *, const int *,
+ const int *, int, const double *, const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
+ x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCbsrmv(cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nb, int nnzb,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *bsrSortedValA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, int blockDim, const cuComplex *x,
+ const cuComplex *beta, cuComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, int, const cuComplex *, const cuComplex *,
+ cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
+ x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrmv(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nb, int nnzb,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *bsrSortedValA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, int blockDim, const cuDoubleComplex *x,
+ const cuDoubleComplex *beta, cuDoubleComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
+ x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSbsrxmv(cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int sizeOfMask, int mb, int nb,
+ int nnzb, const float *alpha, const cusparseMatDescr_t descrA,
+ const float *bsrSortedValA, const int *bsrSortedMaskPtrA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
+ const int *bsrSortedColIndA, int blockDim, const float *x,
+ const float *beta, float *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ int, const float *, const cusparseMatDescr_t, const float *, const int *,
+ const int *, const int *, const int *, int, const float *, const float *,
+ float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrxmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
+ bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDbsrxmv(cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int sizeOfMask, int mb, int nb,
+ int nnzb, const double *alpha, const cusparseMatDescr_t descrA,
+ const double *bsrSortedValA, const int *bsrSortedMaskPtrA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
+ const int *bsrSortedColIndA, int blockDim, const double *x,
+ const double *beta, double *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ int, const double *, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const int *, const int *, int, const double *,
+ const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrxmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
+ bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrxmv(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int sizeOfMask, int mb, int nb, int nnzb,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *bsrSortedValA, const int *bsrSortedMaskPtrA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
+ const int *bsrSortedColIndA, int blockDim, const cuComplex *x,
+ const cuComplex *beta, cuComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ int, const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, const int *, const int *, int,
+ const cuComplex *, const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrxmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
+ bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrxmv(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int sizeOfMask, int mb, int nb, int nnzb,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *bsrSortedValA, const int *bsrSortedMaskPtrA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
+ const int *bsrSortedColIndA, int blockDim, const cuDoubleComplex *x,
+ const cuDoubleComplex *beta, cuDoubleComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ int, const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, const int *,
+ const int *, int, const cuDoubleComplex *, const cuDoubleComplex *,
+ cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrxmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
+ bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsrsv_analysisEx(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const void *csrSortedValA,
+ cudaDataType csrSortedValAtype, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ cudaDataType executiontype) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const void *, cudaDataType, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, cudaDataType);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrsv_analysisEx");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedValAtype, csrSortedRowPtrA, csrSortedColIndA, info,
+ executiontype);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsrsv_solveEx(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ const void *alpha, cudaDataType alphatype, const cusparseMatDescr_t descrA,
+ const void *csrSortedValA, cudaDataType csrSortedValAtype,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info, const void *f, cudaDataType ftype,
+ void *x, cudaDataType xtype, cudaDataType executiontype) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const void *, cudaDataType,
+ const cusparseMatDescr_t, const void *, cudaDataType, const int *,
+ const int *, cusparseSolveAnalysisInfo_t, const void *, cudaDataType,
+ void *, cudaDataType, cudaDataType);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrsv_solveEx");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, alpha, alphatype, descrA, csrSortedValA,
+ csrSortedValAtype, csrSortedRowPtrA, csrSortedColIndA, info,
+ f, ftype, x, xtype, executiontype);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const float *f, float *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const double *f, double *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const cuComplex *f, cuComplex *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const cuDoubleComplex *f, cuDoubleComplex *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, cusparseSolveAnalysisInfo_t, const cuDoubleComplex *,
+ cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrsv2_zeroPivot(cusparseHandle_t handle,
+ csrsv2Info_t info,
+ int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, csrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrsv2_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, csrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, csrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, csrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, csrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, csrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, csrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, csrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, csrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, csrsv2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, csrsv2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, csrsv2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, csrsv2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrsv2Info_t info, const float *f, float *x,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ csrsv2Info_t, const float *, float *, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrsv2Info_t info, const double *f, double *x,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ csrsv2Info_t, const double *, double *, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrsv2Info_t info, const cuComplex *f,
+ cuComplex *x, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ csrsv2Info_t, const cuComplex *, cuComplex *, cusparseSolvePolicy_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrsv2Info_t info, const cuDoubleComplex *f,
+ cuDoubleComplex *x, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, csrsv2Info_t, const cuDoubleComplex *, cuDoubleComplex *,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXbsrsv2_zeroPivot(cusparseHandle_t handle,
+ bsrsv2Info_t info,
+ int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsrsv2_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, float *, const int *, const int *, int,
+ bsrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, double *, const int *, const int *, int,
+ bsrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, cuComplex *, const int *, const int *, int,
+ bsrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, cuDoubleComplex *, const int *, const int *,
+ int, bsrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
+ bsrsv2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, float *, const int *, const int *, int,
+ bsrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
+ pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
+ bsrsv2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, double *, const int *, const int *, int,
+ bsrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
+ pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
+ bsrsv2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, cuComplex *, const int *, const int *, int,
+ bsrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
+ pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
+ bsrsv2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, cuDoubleComplex *, const int *, const int *,
+ int, bsrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
+ pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, const float *, const int *, const int *, int,
+ bsrsv2Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, const double *, const int *, const int *, int,
+ bsrsv2Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ int, bsrsv2Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, int, bsrsv2Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb, const float *alpha,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, const float *f, float *x, cusparseSolvePolicy_t policy,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const float *, const cusparseMatDescr_t, const float *, const int *,
+ const int *, int, bsrsv2Info_t, const float *, float *,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
+ policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb, const double *alpha,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, const double *f, double *x, cusparseSolvePolicy_t policy,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const double *, const cusparseMatDescr_t, const double *, const int *,
+ const int *, int, bsrsv2Info_t, const double *, double *,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
+ policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, const cuComplex *f, cuComplex *x,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, int, bsrsv2Info_t, const cuComplex *,
+ cuComplex *, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
+ policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, const cuDoubleComplex *f, cuDoubleComplex *x,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, bsrsv2Info_t,
+ const cuDoubleComplex *, cuDoubleComplex *, cusparseSolvePolicy_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
+ policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseShybsv_analysis(cusparseHandle_t handle, cusparseOperation_t transA,
+ const cusparseMatDescr_t descrA, cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cusparseMatDescr_t,
+ cusparseHybMat_t, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShybsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, descrA, hybA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDhybsv_analysis(cusparseHandle_t handle, cusparseOperation_t transA,
+ const cusparseMatDescr_t descrA, cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cusparseMatDescr_t,
+ cusparseHybMat_t, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhybsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, descrA, hybA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseChybsv_analysis(cusparseHandle_t handle, cusparseOperation_t transA,
+ const cusparseMatDescr_t descrA, cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cusparseMatDescr_t,
+ cusparseHybMat_t, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChybsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, descrA, hybA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZhybsv_analysis(cusparseHandle_t handle, cusparseOperation_t transA,
+ const cusparseMatDescr_t descrA, cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cusparseMatDescr_t,
+ cusparseHybMat_t, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhybsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, descrA, hybA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseShybsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t trans, const float *alpha,
+ const cusparseMatDescr_t descrA, const cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info, const float *f, float *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const float *,
+ const cusparseMatDescr_t, const cusparseHybMat_t,
+ cusparseSolveAnalysisInfo_t, const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShybsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, alpha, descrA, hybA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseChybsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t trans, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, const cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info, const cuComplex *f, cuComplex *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cuComplex *,
+ const cusparseMatDescr_t, const cusparseHybMat_t,
+ cusparseSolveAnalysisInfo_t, const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChybsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, alpha, descrA, hybA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDhybsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t trans, const double *alpha,
+ const cusparseMatDescr_t descrA, const cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info, const double *f, double *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const double *,
+ const cusparseMatDescr_t, const cusparseHybMat_t,
+ cusparseSolveAnalysisInfo_t, const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhybsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, alpha, descrA, hybA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZhybsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t trans,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA, cusparseSolveAnalysisInfo_t info,
+ const cuDoubleComplex *f, cuDoubleComplex *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cusparseHybMat_t,
+ cusparseSolveAnalysisInfo_t, const cuDoubleComplex *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhybsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, alpha, descrA, hybA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseScsrmm(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, int k, int nnz, const float *alpha,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const float *B, int ldb, const float *beta, float *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ const float *, int, const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, k, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrmm(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int k,
+ int nnz, const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const double *B, int ldb, const double *beta,
+ double *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ const double *, int, const double *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, k, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrmm(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int k,
+ int nnz, const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuComplex *B, int ldb,
+ const cuComplex *beta, cuComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int,
+ const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, const cuComplex *, int, const cuComplex *,
+ cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, k, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrmm(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int k,
+ int nnz, const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *B, int ldb,
+ const cuDoubleComplex *beta, cuDoubleComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int,
+ const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, k, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseScsrmm2(cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k, int nnz,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *B, int ldb,
+ const float *beta, float *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ int, const float *, const cusparseMatDescr_t, const float *, const int *,
+ const int *, const float *, int, const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrmm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDcsrmm2(cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k, int nnz,
+ const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const double *B, int ldb,
+ const double *beta, double *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ int, const double *, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, int, const double *, double *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrmm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCcsrmm2(cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k, int nnz,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuComplex *B, int ldb,
+ const cuComplex *beta, cuComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ int, const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, const cuComplex *, int, const cuComplex *,
+ cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrmm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrmm2(
+ cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k, int nnz,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *B, int ldb,
+ const cuDoubleComplex *beta, cuDoubleComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ int, const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrmm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrmm(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int kb, int nnzb, const float *alpha, const cusparseMatDescr_t descrA,
+ const float *bsrSortedValA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, const int blockSize, const float *B,
+ const int ldb, const float *beta, float *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ const int, const float *, const int, const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
+ B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrmm(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int kb, int nnzb, const double *alpha, const cusparseMatDescr_t descrA,
+ const double *bsrSortedValA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, const int blockSize, const double *B,
+ const int ldb, const double *beta, double *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ const int, const double *, const int, const double *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
+ B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrmm(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int kb, int nnzb, const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *bsrSortedValA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, const int blockSize, const cuComplex *B,
+ const int ldb, const cuComplex *beta, cuComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ const int, const cuComplex *, const int, const cuComplex *, cuComplex *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
+ B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrmm(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int kb, int nnzb, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA,
+ const int blockSize, const cuDoubleComplex *B, const int ldb,
+ const cuDoubleComplex *beta, cuDoubleComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, const int, const cuDoubleComplex *, const int,
+ const cuDoubleComplex *, cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
+ B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgemmi(
+ cusparseHandle_t handle, int m, int n, int k, int nnz,
+ const float *alpha, /* host or device pointer */
+ const float *A, int lda, const float *cscValB, const int *cscColPtrB,
+ const int *cscRowIndB, const float *beta, /* host or device pointer */
+ float *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int, const float *, const float *, int,
+ const float *, const int *, const int *, const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgemmi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
+ cscRowIndB, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgemmi(
+ cusparseHandle_t handle, int m, int n, int k, int nnz,
+ const double *alpha, /* host or device pointer */
+ const double *A, int lda, const double *cscValB, const int *cscColPtrB,
+ const int *cscRowIndB, const double *beta, /* host or device pointer */
+ double *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int, const double *, const double *, int,
+ const double *, const int *, const int *, const double *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgemmi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
+ cscRowIndB, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCgemmi(cusparseHandle_t handle, int m, int n, int k, int nnz,
+ const cuComplex *alpha, /* host or device pointer */
+ const cuComplex *A, int lda, const cuComplex *cscValB,
+ const int *cscColPtrB, const int *cscRowIndB,
+ const cuComplex *beta, /* host or device pointer */
+ cuComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int, const cuComplex *,
+ const cuComplex *, int, const cuComplex *, const int *, const int *,
+ const cuComplex *, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgemmi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
+ cscRowIndB, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgemmi(
+ cusparseHandle_t handle, int m, int n, int k, int nnz,
+ const cuDoubleComplex *alpha, /* host or device pointer */
+ const cuDoubleComplex *A, int lda, const cuDoubleComplex *cscValB,
+ const int *cscColPtrB, const int *cscRowIndB,
+ const cuDoubleComplex *beta, /* host or device pointer */
+ cuDoubleComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, int, const cuDoubleComplex *, const int *,
+ const int *, const cuDoubleComplex *, cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgemmi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
+ cscRowIndB, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsm_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsm_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsm_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsm_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsm_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsm_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsm_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsm_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsm_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const float *B, int ldb, float *X, int ldx) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const float *, int, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsm_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, B, ldb, X, ldx);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsm_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const double *B, int ldb, double *X, int ldx) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const double *, int, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsm_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, B, ldb, X, ldx);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsm_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const cuComplex *B, int ldb, cuComplex *X, int ldx) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const cuComplex *, int, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsm_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, B, ldb, X, ldx);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsm_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const cuDoubleComplex *B, int ldb, cuDoubleComplex *X, int ldx) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, cusparseSolveAnalysisInfo_t, const cuDoubleComplex *, int,
+ cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsm_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, B, ldb, X, ldx);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateCsrsm2Info(csrsm2Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrsm2Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsrsm2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrsm2Info(csrsm2Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrsm2Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsrsm2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrsm2_zeroPivot(cusparseHandle_t handle,
+ csrsm2Info_t info,
+ int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, csrsm2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrsm2_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *B, int ldb, csrsm2Info_t info,
+ cusparseSolvePolicy_t policy, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const float *, const cusparseMatDescr_t, const float *, const int *,
+ const int *, const float *, int, csrsm2Info_t, cusparseSolvePolicy_t,
+ size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const double *B, int ldb, csrsm2Info_t info,
+ cusparseSolvePolicy_t policy, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const double *, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, int, csrsm2Info_t,
+ cusparseSolvePolicy_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuComplex *B, int ldb, csrsm2Info_t info,
+ cusparseSolvePolicy_t policy, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, const cuComplex *, int, csrsm2Info_t,
+ cusparseSolvePolicy_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *B, int ldb,
+ csrsm2Info_t info, cusparseSolvePolicy_t policy, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cuDoubleComplex *, int, csrsm2Info_t, cusparseSolvePolicy_t,
+ size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsm2_analysis(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *B, int ldb, csrsm2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const float *, const cusparseMatDescr_t, const float *, const int *,
+ const int *, const float *, int, csrsm2Info_t, cusparseSolvePolicy_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsm2_analysis(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const double *B, int ldb, csrsm2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const double *, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, int, csrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsm2_analysis(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuComplex *B, int ldb, csrsm2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, const cuComplex *, int, csrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsm2_analysis(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *B, int ldb,
+ csrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cuDoubleComplex *, int, csrsm2Info_t, cusparseSolvePolicy_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsm2_solve(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, float *B, int ldb, csrsm2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const float *, const cusparseMatDescr_t, const float *, const int *,
+ const int *, float *, int, csrsm2Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsm2_solve(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, double *B, int ldb, csrsm2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const double *, const cusparseMatDescr_t, const double *,
+ const int *, const int *, double *, int, csrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsm2_solve(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cuComplex *B, int ldb, csrsm2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, cuComplex *, int, csrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsm2_solve(
+ cusparseHandle_t handle, int algo, /* algo = 0, 1 */
+ cusparseOperation_t transA, cusparseOperation_t transB, int m, int nrhs,
+ int nnz, const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cuDoubleComplex *B, int ldb, csrsm2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
+ int, const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, cuDoubleComplex *, int,
+ csrsm2Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXbsrsm2_zeroPivot(cusparseHandle_t handle,
+ bsrsm2Info_t info,
+ int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsrsm2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsrsm2_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, int, bsrsm2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, int, bsrsm2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, int, bsrsm2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrsm2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, int, bsrsm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, int, bsrsm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, int, bsrsm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrsm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, const float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, bsrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, const double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, bsrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, const cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int, bsrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, bsrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const float *alpha, const cusparseMatDescr_t descrA,
+ const float *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
+ const float *B, int ldb, float *X, int ldx, cusparseSolvePolicy_t policy,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *, int,
+ bsrsm2Info_t, const float *, int, float *, int, cusparseSolvePolicy_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, B, ldb, X, ldx, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const double *alpha, const cusparseMatDescr_t descrA,
+ const double *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
+ const double *B, int ldb, double *X, int ldx, cusparseSolvePolicy_t policy,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *, int,
+ bsrsm2Info_t, const double *, int, double *, int, cusparseSolvePolicy_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, B, ldb, X, ldx, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
+ const cuComplex *B, int ldb, cuComplex *X, int ldx,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ int, bsrsm2Info_t, const cuComplex *, int, cuComplex *, int,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, B, ldb, X, ldx, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
+ const cuDoubleComplex *B, int ldb, cuDoubleComplex *X, int ldx,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, int, bsrsm2Info_t, const cuDoubleComplex *, int,
+ cuDoubleComplex *, int, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, B, ldb, X, ldx, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsrilu0Ex(
+ cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, void *csrSortedValA_ValM,
+ cudaDataType csrSortedValA_ValMtype,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info, cudaDataType executiontype) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ void *, cudaDataType, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, cudaDataType);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrilu0Ex");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedValA_ValMtype, csrSortedRowPtrA, csrSortedColIndA,
+ info, executiontype);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseScsrilu0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, float *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDcsrilu0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, double *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCcsrilu0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, cuComplex *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu0(
+ cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_numericBoost(
+ cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
+ float *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, csrilu02Info_t, int, double *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_numericBoost(
+ cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
+ double *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, csrilu02Info_t, int, double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_numericBoost(
+ cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
+ cuComplex *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, csrilu02Info_t, int, double *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_numericBoost(
+ cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
+ cuDoubleComplex *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, csrilu02Info_t, int, double *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrilu02_zeroPivot(
+ cusparseHandle_t handle, csrilu02Info_t info, int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, csrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrilu02_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedVal, const int *csrSortedRowPtr, const int *csrSortedColInd,
+ csrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, csrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrilu02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_numericBoost(
+ cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
+ float *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, bsrilu02Info_t, int, double *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_numericBoost(
+ cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
+ double *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, bsrilu02Info_t, int, double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_numericBoost(
+ cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
+ cuComplex *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, bsrilu02Info_t, int, double *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_numericBoost(
+ cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
+ cuDoubleComplex *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, bsrilu02Info_t, int, double *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXbsrilu02_zeroPivot(
+ cusparseHandle_t handle, bsrilu02Info_t info, int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsrilu02_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t,
+ size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseScsric0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, float *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDcsric0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, double *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCcsric0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, cuComplex *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsric0(
+ cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsric02_zeroPivot(cusparseHandle_t handle,
+ csric02Info_t info,
+ int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, csric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsric02_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsric02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsric02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsric02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsric02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsric02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedVal, const int *csrSortedRowPtr, const int *csrSortedColInd,
+ csric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsric02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsric02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsric02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsric02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsric02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsric02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsric02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, csric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsric02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsric02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsric02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsric02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXbsric02_zeroPivot(cusparseHandle_t handle,
+ bsric02Info_t info,
+ int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsric02_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsric02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsric02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsric02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsric02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsric02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsric02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsric02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsric02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsric02Info_t,
+ size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsric02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pInputBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsric02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pInputBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsric02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pInputBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsric02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pInputBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsric02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsric02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsric02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsric02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv(cusparseHandle_t handle, int m,
+ int n, const float *dl,
+ const float *d, const float *du,
+ float *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, int,
+ const float *, const float *,
+ const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv(cusparseHandle_t handle, int m,
+ int n, const double *dl,
+ const double *d, const double *du,
+ double *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv(cusparseHandle_t handle, int m,
+ int n, const cuComplex *dl,
+ const cuComplex *d,
+ const cuComplex *du, cuComplex *B,
+ int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv(cusparseHandle_t handle, int m,
+ int n, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d,
+ const cuDoubleComplex *du,
+ cuDoubleComplex *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const float *dl, const float *d,
+ const float *du, const float *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const float *, const float *,
+ const float *, int, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const double *dl, const double *d,
+ const double *du, const double *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, const double *, int, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const cuComplex *dl,
+ const cuComplex *d, const cuComplex *du, const cuComplex *B, int ldb,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, const cuComplex *, int, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du,
+ const cuDoubleComplex *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, const cuDoubleComplex *,
+ int, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2(cusparseHandle_t handle, int m,
+ int n, const float *dl,
+ const float *d, const float *du,
+ float *B, int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const float *, const float *,
+ float *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv2(cusparseHandle_t handle, int m,
+ int n, const double *dl,
+ const double *d, const double *du,
+ double *B, int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, double *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2(cusparseHandle_t handle, int m,
+ int n, const cuComplex *dl,
+ const cuComplex *d,
+ const cuComplex *du, cuComplex *B,
+ int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2(cusparseHandle_t handle, int m,
+ int n, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d,
+ const cuDoubleComplex *du,
+ cuDoubleComplex *B, int ldb,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *, int,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSgtsv_nopivot(cusparseHandle_t handle, int m, int n, const float *dl,
+ const float *d, const float *du, float *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, int,
+ const float *, const float *,
+ const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDgtsv_nopivot(cusparseHandle_t handle, int m, int n, const double *dl,
+ const double *d, const double *du, double *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv_nopivot(
+ cusparseHandle_t handle, int m, int n, const cuComplex *dl,
+ const cuComplex *d, const cuComplex *du, cuComplex *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZgtsv_nopivot(cusparseHandle_t handle, int m, int n,
+ const cuDoubleComplex *dl, const cuDoubleComplex *d,
+ const cuDoubleComplex *du, cuDoubleComplex *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_nopivot_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const float *dl, const float *d,
+ const float *du, const float *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const float *, const float *,
+ const float *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSgtsv2_nopivot_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_nopivot_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const double *dl, const double *d,
+ const double *du, const double *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, const double *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDgtsv2_nopivot_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_nopivot_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const cuComplex *dl,
+ const cuComplex *d, const cuComplex *du, const cuComplex *B, int ldb,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, const cuComplex *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCgtsv2_nopivot_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_nopivot_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du,
+ const cuDoubleComplex *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, const cuDoubleComplex *,
+ int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZgtsv2_nopivot_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_nopivot(
+ cusparseHandle_t handle, int m, int n, const float *dl, const float *d,
+ const float *du, float *B, int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const float *, const float *,
+ float *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_nopivot(
+ cusparseHandle_t handle, int m, int n, const double *dl, const double *d,
+ const double *du, double *B, int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, double *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_nopivot(
+ cusparseHandle_t handle, int m, int n, const cuComplex *dl,
+ const cuComplex *d, const cuComplex *du, cuComplex *B, int ldb,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_nopivot(
+ cusparseHandle_t handle, int m, int n, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du, cuDoubleComplex *B,
+ int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *, int,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsvStridedBatch(
+ cusparseHandle_t handle, int m, const float *dl, const float *d,
+ const float *du, float *x, int batchCount, int batchStride) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, const float *, const float *,
+ float *, int, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsvStridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsvStridedBatch(
+ cusparseHandle_t handle, int m, const double *dl, const double *d,
+ const double *du, double *x, int batchCount, int batchStride) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const double *, const double *,
+ double *, int, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsvStridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsvStridedBatch(
+ cusparseHandle_t handle, int m, const cuComplex *dl, const cuComplex *d,
+ const cuComplex *du, cuComplex *x, int batchCount, int batchStride) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsvStridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsvStridedBatch(
+ cusparseHandle_t handle, int m, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du, cuDoubleComplex *x,
+ int batchCount, int batchStride) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
+ const cuDoubleComplex *, cuDoubleComplex *, int, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsvStridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2StridedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int m, const float *dl, const float *d,
+ const float *du, const float *x, int batchCount, int batchStride,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, const float *, const float *,
+ const float *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSgtsv2StridedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
+ bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv2StridedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int m, const double *dl, const double *d,
+ const double *du, const double *x, int batchCount, int batchStride,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const double *, const double *,
+ const double *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDgtsv2StridedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
+ bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2StridedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int m, const cuComplex *dl, const cuComplex *d,
+ const cuComplex *du, const cuComplex *x, int batchCount, int batchStride,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, const cuComplex *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCgtsv2StridedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
+ bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2StridedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int m, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du,
+ const cuDoubleComplex *x, int batchCount, int batchStride,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZgtsv2StridedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
+ bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2StridedBatch(
+ cusparseHandle_t handle, int m, const float *dl, const float *d,
+ const float *du, float *x, int batchCount, int batchStride, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, const float *, const float *,
+ float *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2StridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDgtsv2StridedBatch(cusparseHandle_t handle, int m, const double *dl,
+ const double *d, const double *du, double *x,
+ int batchCount, int batchStride, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const double *, const double *,
+ double *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2StridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2StridedBatch(
+ cusparseHandle_t handle, int m, const cuComplex *dl, const cuComplex *d,
+ const cuComplex *du, cuComplex *x, int batchCount, int batchStride,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2StridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2StridedBatch(
+ cusparseHandle_t handle, int m, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du, cuDoubleComplex *x,
+ int batchCount, int batchStride, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
+ const cuDoubleComplex *, cuDoubleComplex *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2StridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsvInterleavedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int algo, int m, const float *dl, const float *d,
+ const float *du, const float *x, int batchCount,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const float *, const float *,
+ const float *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSgtsvInterleavedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, dl, d, du, x, batchCount,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsvInterleavedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int algo, int m, const double *dl, const double *d,
+ const double *du, const double *x, int batchCount,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, const double *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDgtsvInterleavedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, dl, d, du, x, batchCount,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsvInterleavedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int algo, int m, const cuComplex *dl,
+ const cuComplex *d, const cuComplex *du, const cuComplex *x, int batchCount,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, const cuComplex *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCgtsvInterleavedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, dl, d, du, x, batchCount,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsvInterleavedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int algo, int m, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du,
+ const cuDoubleComplex *x, int batchCount, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, const cuDoubleComplex *,
+ int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZgtsvInterleavedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, dl, d, du, x, batchCount,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsvInterleavedBatch(
+ cusparseHandle_t handle, int algo, int m, float *dl, float *d, float *du,
+ float *x, int batchCount, void *pBuffer) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, int, float *,
+ float *, float *, float *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsvInterleavedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, dl, d, du, x, batchCount, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsvInterleavedBatch(
+ cusparseHandle_t handle, int algo, int m, double *dl, double *d, double *du,
+ double *x, int batchCount, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, int,
+ double *, double *, double *,
+ double *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsvInterleavedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, dl, d, du, x, batchCount, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsvInterleavedBatch(
+ cusparseHandle_t handle, int algo, int m, cuComplex *dl, cuComplex *d,
+ cuComplex *du, cuComplex *x, int batchCount, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, cuComplex *, cuComplex *, cuComplex *,
+ cuComplex *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsvInterleavedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, dl, d, du, x, batchCount, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsvInterleavedBatch(
+ cusparseHandle_t handle, int algo, int m, cuDoubleComplex *dl,
+ cuDoubleComplex *d, cuDoubleComplex *du, cuDoubleComplex *x, int batchCount,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, cuDoubleComplex *, cuDoubleComplex *,
+ cuDoubleComplex *, cuDoubleComplex *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsvInterleavedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, dl, d, du, x, batchCount, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgpsvInterleavedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int algo, int m, const float *ds, const float *dl,
+ const float *d, const float *du, const float *dw, const float *x,
+ int batchCount, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const float *, const float *,
+ const float *, const float *, const float *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSgpsvInterleavedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgpsvInterleavedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int algo, int m, const double *ds,
+ const double *dl, const double *d, const double *du, const double *dw,
+ const double *x, int batchCount, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, const double *, const double *, const double *, int,
+ size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDgpsvInterleavedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgpsvInterleavedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int algo, int m, const cuComplex *ds,
+ const cuComplex *dl, const cuComplex *d, const cuComplex *du,
+ const cuComplex *dw, const cuComplex *x, int batchCount,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, const cuComplex *, const cuComplex *,
+ const cuComplex *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCgpsvInterleavedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgpsvInterleavedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int algo, int m, const cuDoubleComplex *ds,
+ const cuDoubleComplex *dl, const cuDoubleComplex *d,
+ const cuDoubleComplex *du, const cuDoubleComplex *dw,
+ const cuDoubleComplex *x, int batchCount, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZgpsvInterleavedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgpsvInterleavedBatch(
+ cusparseHandle_t handle, int algo, int m, float *ds, float *dl, float *d,
+ float *du, float *dw, float *x, int batchCount, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, float *, float *, float *, float *, float *,
+ float *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgpsvInterleavedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgpsvInterleavedBatch(
+ cusparseHandle_t handle, int algo, int m, double *ds, double *dl, double *d,
+ double *du, double *dw, double *x, int batchCount, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, double *, double *, double *, double *,
+ double *, double *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgpsvInterleavedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgpsvInterleavedBatch(
+ cusparseHandle_t handle, int algo, int m, cuComplex *ds, cuComplex *dl,
+ cuComplex *d, cuComplex *du, cuComplex *dw, cuComplex *x, int batchCount,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, cuComplex *, cuComplex *, cuComplex *,
+ cuComplex *, cuComplex *, cuComplex *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgpsvInterleavedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgpsvInterleavedBatch(
+ cusparseHandle_t handle, int algo, int m, cuDoubleComplex *ds,
+ cuDoubleComplex *dl, cuDoubleComplex *d, cuDoubleComplex *du,
+ cuDoubleComplex *dw, cuDoubleComplex *x, int batchCount, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, cuDoubleComplex *, cuDoubleComplex *,
+ cuDoubleComplex *, cuDoubleComplex *, cuDoubleComplex *,
+ cuDoubleComplex *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgpsvInterleavedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseXcsrgemmNnz(cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k,
+ const cusparseMatDescr_t descrA, const int nnzA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, const int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, int *csrSortedRowPtrC,
+ int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ const cusparseMatDescr_t, const int, const int *, const int *,
+ const cusparseMatDescr_t, const int, const int *, const int *,
+ const cusparseMatDescr_t, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrgemmNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, descrA, nnzA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrgemm(
+ cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k,
+ const cusparseMatDescr_t descrA, const int nnzA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, const int nnzB, const float *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, float *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ const cusparseMatDescr_t, const int, const float *, const int *,
+ const int *, const cusparseMatDescr_t, const int, const float *,
+ const int *, const int *, const cusparseMatDescr_t, float *, const int *,
+ int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgemm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrgemm(
+ cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k,
+ const cusparseMatDescr_t descrA, int nnzA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const double *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, double *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ const cusparseMatDescr_t, int, const double *, const int *, const int *,
+ const cusparseMatDescr_t, int, const double *, const int *, const int *,
+ const cusparseMatDescr_t, double *, const int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgemm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrgemm(
+ cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k,
+ const cusparseMatDescr_t descrA, int nnzA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const cuComplex *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, cuComplex *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ const cusparseMatDescr_t, int, const cuComplex *, const int *,
+ const int *, const cusparseMatDescr_t, int, const cuComplex *,
+ const int *, const int *, const cusparseMatDescr_t, cuComplex *,
+ const int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgemm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrgemm(
+ cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k,
+ const cusparseMatDescr_t descrA, int nnzA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const cuDoubleComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ cuDoubleComplex *csrSortedValC, const int *csrSortedRowPtrC,
+ int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
+ const int *, const cusparseMatDescr_t, int, const cuDoubleComplex *,
+ const int *, const int *, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgemm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateCsrgemm2Info(csrgemm2Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrgemm2Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsrgemm2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrgemm2Info(csrgemm2Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrgemm2Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsrgemm2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrgemm2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int k, const float *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB, const float *beta,
+ const cusparseMatDescr_t descrD, int nnzD, const int *csrSortedRowPtrD,
+ const int *csrSortedColIndD, csrgemm2Info_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const cusparseMatDescr_t,
+ int, const int *, const int *, const cusparseMatDescr_t, int, const int *,
+ const int *, const float *, const cusparseMatDescr_t, int, const int *,
+ const int *, csrgemm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgemm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
+ csrSortedColIndD, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrgemm2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int k, const double *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const double *beta, const cusparseMatDescr_t descrD, int nnzD,
+ const int *csrSortedRowPtrD, const int *csrSortedColIndD,
+ csrgemm2Info_t info, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const cusparseMatDescr_t,
+ int, const int *, const int *, const cusparseMatDescr_t, int, const int *,
+ const int *, const double *, const cusparseMatDescr_t, int, const int *,
+ const int *, csrgemm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgemm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
+ csrSortedColIndD, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrgemm2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int k, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cuComplex *beta, const cusparseMatDescr_t descrD, int nnzD,
+ const int *csrSortedRowPtrD, const int *csrSortedColIndD,
+ csrgemm2Info_t info, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, int, const int *, const int *,
+ const cusparseMatDescr_t, int, const int *, const int *,
+ const cuComplex *, const cusparseMatDescr_t, int, const int *,
+ const int *, csrgemm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgemm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
+ csrSortedColIndD, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrgemm2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int k, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cuDoubleComplex *beta, const cusparseMatDescr_t descrD, int nnzD,
+ const int *csrSortedRowPtrD, const int *csrSortedColIndD,
+ csrgemm2Info_t info, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, int, const int *, const int *,
+ const cusparseMatDescr_t, int, const int *, const int *,
+ const cuDoubleComplex *, const cusparseMatDescr_t, int, const int *,
+ const int *, csrgemm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgemm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
+ csrSortedColIndD, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrgemm2Nnz(
+ cusparseHandle_t handle, int m, int n, int k,
+ const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrD, int nnzD, const int *csrSortedRowPtrD,
+ const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
+ int *csrSortedRowPtrC, int *nnzTotalDevHostPtr, const csrgemm2Info_t info,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, int,
+ const int *, const int *, const cusparseMatDescr_t, int, const int *,
+ const int *, const cusparseMatDescr_t, int, const int *, const int *,
+ const cusparseMatDescr_t, int *, int *, const csrgemm2Info_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrgemm2Nnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, descrD, nnzD, csrSortedRowPtrD,
+ csrSortedColIndD, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrgemm2(
+ cusparseHandle_t handle, int m, int n, int k, const float *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const float *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB, const float *beta,
+ const cusparseMatDescr_t descrD, int nnzD, const float *csrSortedValD,
+ const int *csrSortedRowPtrD, const int *csrSortedColIndD,
+ const cusparseMatDescr_t descrC, float *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC,
+ const csrgemm2Info_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const cusparseMatDescr_t,
+ int, const float *, const int *, const int *, const cusparseMatDescr_t,
+ int, const float *, const int *, const int *, const float *,
+ const cusparseMatDescr_t, int, const float *, const int *, const int *,
+ const cusparseMatDescr_t, float *, const int *, int *,
+ const csrgemm2Info_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgemm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
+ descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
+ csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
+ csrSortedColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrgemm2(
+ cusparseHandle_t handle, int m, int n, int k, const double *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const double *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const double *beta, const cusparseMatDescr_t descrD, int nnzD,
+ const double *csrSortedValD, const int *csrSortedRowPtrD,
+ const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
+ double *csrSortedValC, const int *csrSortedRowPtrC, int *csrSortedColIndC,
+ const csrgemm2Info_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const cusparseMatDescr_t,
+ int, const double *, const int *, const int *, const cusparseMatDescr_t,
+ int, const double *, const int *, const int *, const double *,
+ const cusparseMatDescr_t, int, const double *, const int *, const int *,
+ const cusparseMatDescr_t, double *, const int *, int *,
+ const csrgemm2Info_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgemm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
+ descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
+ csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
+ csrSortedColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrgemm2(
+ cusparseHandle_t handle, int m, int n, int k, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const cuComplex *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cuComplex *beta, const cusparseMatDescr_t descrD, int nnzD,
+ const cuComplex *csrSortedValD, const int *csrSortedRowPtrD,
+ const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
+ cuComplex *csrSortedValC, const int *csrSortedRowPtrC,
+ int *csrSortedColIndC, const csrgemm2Info_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, int, const cuComplex *, const int *,
+ const int *, const cusparseMatDescr_t, int, const cuComplex *,
+ const int *, const int *, const cuComplex *, const cusparseMatDescr_t,
+ int, const cuComplex *, const int *, const int *,
+ const cusparseMatDescr_t, cuComplex *, const int *, int *,
+ const csrgemm2Info_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgemm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
+ descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
+ csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
+ csrSortedColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrgemm2(
+ cusparseHandle_t handle, int m, int n, int k, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const cuDoubleComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cuDoubleComplex *beta,
+ const cusparseMatDescr_t descrD, int nnzD,
+ const cuDoubleComplex *csrSortedValD, const int *csrSortedRowPtrD,
+ const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
+ cuDoubleComplex *csrSortedValC, const int *csrSortedRowPtrC,
+ int *csrSortedColIndC, const csrgemm2Info_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
+ const int *, const cusparseMatDescr_t, int, const cuDoubleComplex *,
+ const int *, const int *, const cuDoubleComplex *,
+ const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
+ const int *, const cusparseMatDescr_t, cuDoubleComplex *, const int *,
+ int *, const csrgemm2Info_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgemm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
+ descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
+ csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
+ csrSortedColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrgeamNnz(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ int nnzA, const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ int *csrSortedRowPtrC, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, int, const int *,
+ const int *, const cusparseMatDescr_t, int, const int *, const int *,
+ const cusparseMatDescr_t, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrgeamNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrgeam(
+ cusparseHandle_t handle, int m, int n, const float *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, const float *beta,
+ const cusparseMatDescr_t descrB, int nnzB, const float *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, float *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const cusparseMatDescr_t, int,
+ const float *, const int *, const int *, const float *,
+ const cusparseMatDescr_t, int, const float *, const int *, const int *,
+ const cusparseMatDescr_t, float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgeam");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrgeam(
+ cusparseHandle_t handle, int m, int n, const double *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const double *beta, const cusparseMatDescr_t descrB, int nnzB,
+ const double *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ double *csrSortedValC, int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const cusparseMatDescr_t, int,
+ const double *, const int *, const int *, const double *,
+ const cusparseMatDescr_t, int, const double *, const int *, const int *,
+ const cusparseMatDescr_t, double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgeam");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrgeam(
+ cusparseHandle_t handle, int m, int n, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cuComplex *beta, const cusparseMatDescr_t descrB, int nnzB,
+ const cuComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ cuComplex *csrSortedValC, int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cusparseMatDescr_t,
+ int, const cuComplex *, const int *, const int *, const cuComplex *,
+ const cusparseMatDescr_t, int, const cuComplex *, const int *,
+ const int *, const cusparseMatDescr_t, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgeam");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrgeam(
+ cusparseHandle_t handle, int m, int n, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *beta,
+ const cusparseMatDescr_t descrB, int nnzB,
+ const cuDoubleComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ cuDoubleComplex *csrSortedValC, int *csrSortedRowPtrC,
+ int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
+ const int *, const cuDoubleComplex *, const cusparseMatDescr_t, int,
+ const cuDoubleComplex *, const int *, const int *,
+ const cusparseMatDescr_t, cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgeam");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrgeam2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const float *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, const float *beta,
+ const cusparseMatDescr_t descrB, int nnzB, const float *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, const float *csrSortedValC,
+ const int *csrSortedRowPtrC, const int *csrSortedColIndC,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const cusparseMatDescr_t, int,
+ const float *, const int *, const int *, const float *,
+ const cusparseMatDescr_t, int, const float *, const int *, const int *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgeam2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrgeam2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const double *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const double *beta, const cusparseMatDescr_t descrB, int nnzB,
+ const double *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ const double *csrSortedValC, const int *csrSortedRowPtrC,
+ const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const cusparseMatDescr_t, int,
+ const double *, const int *, const int *, const double *,
+ const cusparseMatDescr_t, int, const double *, const int *, const int *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgeam2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrgeam2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cuComplex *beta, const cusparseMatDescr_t descrB, int nnzB,
+ const cuComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ const cuComplex *csrSortedValC, const int *csrSortedRowPtrC,
+ const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cusparseMatDescr_t,
+ int, const cuComplex *, const int *, const int *, const cuComplex *,
+ const cusparseMatDescr_t, int, const cuComplex *, const int *,
+ const int *, const cusparseMatDescr_t, const cuComplex *, const int *,
+ const int *, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgeam2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrgeam2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *beta,
+ const cusparseMatDescr_t descrB, int nnzB,
+ const cuDoubleComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ const cuDoubleComplex *csrSortedValC, const int *csrSortedRowPtrC,
+ const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
+ const int *, const cuDoubleComplex *, const cusparseMatDescr_t, int,
+ const cuDoubleComplex *, const int *, const int *,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgeam2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrgeam2Nnz(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ int nnzA, const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ int *csrSortedRowPtrC, int *nnzTotalDevHostPtr, void *workspace) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, int, const int *,
+ const int *, const cusparseMatDescr_t, int, const int *, const int *,
+ const cusparseMatDescr_t, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrgeam2Nnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr, workspace);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrgeam2(
+ cusparseHandle_t handle, int m, int n, const float *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, const float *beta,
+ const cusparseMatDescr_t descrB, int nnzB, const float *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, float *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const cusparseMatDescr_t, int,
+ const float *, const int *, const int *, const float *,
+ const cusparseMatDescr_t, int, const float *, const int *, const int *,
+ const cusparseMatDescr_t, float *, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgeam2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrgeam2(
+ cusparseHandle_t handle, int m, int n, const double *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const double *beta, const cusparseMatDescr_t descrB, int nnzB,
+ const double *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ double *csrSortedValC, int *csrSortedRowPtrC, int *csrSortedColIndC,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const cusparseMatDescr_t, int,
+ const double *, const int *, const int *, const double *,
+ const cusparseMatDescr_t, int, const double *, const int *, const int *,
+ const cusparseMatDescr_t, double *, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgeam2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrgeam2(
+ cusparseHandle_t handle, int m, int n, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cuComplex *beta, const cusparseMatDescr_t descrB, int nnzB,
+ const cuComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ cuComplex *csrSortedValC, int *csrSortedRowPtrC, int *csrSortedColIndC,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cusparseMatDescr_t,
+ int, const cuComplex *, const int *, const int *, const cuComplex *,
+ const cusparseMatDescr_t, int, const cuComplex *, const int *,
+ const int *, const cusparseMatDescr_t, cuComplex *, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgeam2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrgeam2(
+ cusparseHandle_t handle, int m, int n, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *beta,
+ const cusparseMatDescr_t descrB, int nnzB,
+ const cuDoubleComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ cuDoubleComplex *csrSortedValC, int *csrSortedRowPtrC,
+ int *csrSortedColIndC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
+ const int *, const cuDoubleComplex *, const cusparseMatDescr_t, int,
+ const cuDoubleComplex *, const int *, const int *,
+ const cusparseMatDescr_t, cuDoubleComplex *, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgeam2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrcolor(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *fractionToColor, int *ncolors,
+ int *coloring, int *reordering, const cusparseColorInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, const float *, int *, int *, int *,
+ const cusparseColorInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrcolor");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, fractionToColor, ncolors, coloring,
+ reordering, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrcolor(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const double *fractionToColor, int *ncolors,
+ int *coloring, int *reordering, const cusparseColorInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, int *, int *, int *,
+ const cusparseColorInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrcolor");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, fractionToColor, ncolors, coloring,
+ reordering, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrcolor(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *fractionToColor, int *ncolors,
+ int *coloring, int *reordering, const cusparseColorInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, const float *, int *, int *, int *,
+ const cusparseColorInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrcolor");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, fractionToColor, ncolors, coloring,
+ reordering, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrcolor(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const double *fractionToColor, int *ncolors,
+ int *coloring, int *reordering, const cusparseColorInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, const double *, int *,
+ int *, int *, const cusparseColorInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrcolor");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, fractionToColor, ncolors, coloring,
+ reordering, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const float *A, int lda,
+ int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, int, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSnnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const double *A, int lda,
+ int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, int, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuComplex *A, int lda,
+ int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, int, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCnnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *A, int lda,
+ int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, int, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZnnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSnnz_compress(
+ cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
+ const float *csrSortedValA, const int *csrSortedRowPtrA, int *nnzPerRow,
+ int *nnzC, float tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cusparseMatDescr_t, const float *,
+ const int *, int *, int *, float);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSnnz_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, descr, csrSortedValA, csrSortedRowPtrA, nnzPerRow,
+ nnzC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDnnz_compress(
+ cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
+ const double *csrSortedValA, const int *csrSortedRowPtrA, int *nnzPerRow,
+ int *nnzC, double tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cusparseMatDescr_t, const double *,
+ const int *, int *, int *, double);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnnz_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, descr, csrSortedValA, csrSortedRowPtrA, nnzPerRow,
+ nnzC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCnnz_compress(
+ cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA, int *nnzPerRow,
+ int *nnzC, cuComplex tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, int *, int *, cuComplex);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCnnz_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, descr, csrSortedValA, csrSortedRowPtrA, nnzPerRow,
+ nnzC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZnnz_compress(
+ cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ int *nnzPerRow, int *nnzC, cuDoubleComplex tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cusparseMatDescr_t, const cuDoubleComplex *,
+ const int *, int *, int *, cuDoubleComplex);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZnnz_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, descr, csrSortedValA, csrSortedRowPtrA, nnzPerRow,
+ nnzC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2csr_compress(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedColIndA,
+ const int *csrSortedRowPtrA, int nnzA, const int *nnzPerRow,
+ float *csrSortedValC, int *csrSortedColIndC, int *csrSortedRowPtrC,
+ float tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, int, const int *, float *, int *, int *, float);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2csr_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedColIndA,
+ csrSortedRowPtrA, nnzA, nnzPerRow, csrSortedValC,
+ csrSortedColIndC, csrSortedRowPtrC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2csr_compress(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedColIndA,
+ const int *csrSortedRowPtrA, int nnzA, const int *nnzPerRow,
+ double *csrSortedValC, int *csrSortedColIndC, int *csrSortedRowPtrC,
+ double tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, int, const int *, double *, int *, int *,
+ double);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2csr_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedColIndA,
+ csrSortedRowPtrA, nnzA, nnzPerRow, csrSortedValC,
+ csrSortedColIndC, csrSortedRowPtrC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2csr_compress(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedColIndA,
+ const int *csrSortedRowPtrA, int nnzA, const int *nnzPerRow,
+ cuComplex *csrSortedValC, int *csrSortedColIndC, int *csrSortedRowPtrC,
+ cuComplex tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, int, const int *, cuComplex *, int *, int *,
+ cuComplex);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2csr_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedColIndA,
+ csrSortedRowPtrA, nnzA, nnzPerRow, csrSortedValC,
+ csrSortedColIndC, csrSortedRowPtrC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2csr_compress(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedColIndA,
+ const int *csrSortedRowPtrA, int nnzA, const int *nnzPerRow,
+ cuDoubleComplex *csrSortedValC, int *csrSortedColIndC,
+ int *csrSortedRowPtrC, cuDoubleComplex tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, const int *,
+ cuDoubleComplex *, int *, int *, cuDoubleComplex);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2csr_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedColIndA,
+ csrSortedRowPtrA, nnzA, nnzPerRow, csrSortedValC,
+ csrSortedColIndC, csrSortedRowPtrC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSdense2csr(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *A, int lda, const int *nnzPerRow, float *csrSortedValA,
+ int *csrSortedRowPtrA, int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *, int,
+ const int *, float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSdense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDdense2csr(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *A, int lda, const int *nnzPerRow, double *csrSortedValA,
+ int *csrSortedRowPtrA, int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *, int,
+ const int *, double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDdense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCdense2csr(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *A, int lda, const int *nnzPerRow, cuComplex *csrSortedValA,
+ int *csrSortedRowPtrA, int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ int, const int *, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZdense2csr(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *A, int lda, const int *nnzPerRow,
+ cuDoubleComplex *csrSortedValA, int *csrSortedRowPtrA,
+ int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, int, const int *, cuDoubleComplex *, int *,
+ int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, float *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, double *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cuComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cuDoubleComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, cuDoubleComplex *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSdense2csc(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *A, int lda, const int *nnzPerCol, float *cscSortedValA,
+ int *cscSortedRowIndA, int *cscSortedColPtrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *, int,
+ const int *, float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSdense2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
+ cscSortedRowIndA, cscSortedColPtrA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDdense2csc(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *A, int lda, const int *nnzPerCol, double *cscSortedValA,
+ int *cscSortedRowIndA, int *cscSortedColPtrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *, int,
+ const int *, double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDdense2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
+ cscSortedRowIndA, cscSortedColPtrA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCdense2csc(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *A, int lda, const int *nnzPerCol, cuComplex *cscSortedValA,
+ int *cscSortedRowIndA, int *cscSortedColPtrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ int, const int *, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdense2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
+ cscSortedRowIndA, cscSortedColPtrA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZdense2csc(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *A, int lda, const int *nnzPerCol,
+ cuDoubleComplex *cscSortedValA, int *cscSortedRowIndA,
+ int *cscSortedColPtrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, int, const int *, cuDoubleComplex *, int *,
+ int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdense2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
+ cscSortedRowIndA, cscSortedColPtrA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsc2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, float *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsc2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsc2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, double *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsc2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsc2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cuComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsc2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsc2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cuDoubleComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, cuDoubleComplex *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsc2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcoo2csr(cusparseHandle_t handle,
+ const int *cooRowInd, int nnz,
+ int m, int *csrSortedRowPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const int *, int, int, int *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoo2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, cooRowInd, nnz, m, csrSortedRowPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsr2coo(cusparseHandle_t handle,
+ const int *csrSortedRowPtr,
+ int nnz, int m, int *cooRowInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const int *, int, int, int *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsr2coo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, csrSortedRowPtr, nnz, m, cooRowInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsr2cscEx(
+ cusparseHandle_t handle, int m, int n, int nnz, const void *csrSortedVal,
+ cudaDataType csrSortedValtype, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, void *cscSortedVal,
+ cudaDataType cscSortedValtype, int *cscSortedRowInd, int *cscSortedColPtr,
+ cusparseAction_t copyValues, cusparseIndexBase_t idxBase,
+ cudaDataType executiontype) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const void *, cudaDataType, const int *,
+ const int *, void *, cudaDataType, int *, int *, cusparseAction_t,
+ cusparseIndexBase_t, cudaDataType);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsr2cscEx");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrSortedVal, csrSortedValtype,
+ csrSortedRowPtr, csrSortedColInd, cscSortedVal,
+ cscSortedValtype, cscSortedRowInd, cscSortedColPtr,
+ copyValues, idxBase, executiontype);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2csc(
+ cusparseHandle_t handle, int m, int n, int nnz, const float *csrSortedVal,
+ const int *csrSortedRowPtr, const int *csrSortedColInd, float *cscSortedVal,
+ int *cscSortedRowInd, int *cscSortedColPtr, cusparseAction_t copyValues,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const int *, const int *,
+ float *, int *, int *, cusparseAction_t, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr, copyValues, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2csc(
+ cusparseHandle_t handle, int m, int n, int nnz, const double *csrSortedVal,
+ const int *csrSortedRowPtr, const int *csrSortedColInd,
+ double *cscSortedVal, int *cscSortedRowInd, int *cscSortedColPtr,
+ cusparseAction_t copyValues, cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const int *, const int *,
+ double *, int *, int *, cusparseAction_t, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr, copyValues, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCcsr2csc(cusparseHandle_t handle, int m, int n, int nnz,
+ const cuComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, cuComplex *cscSortedVal,
+ int *cscSortedRowInd, int *cscSortedColPtr,
+ cusparseAction_t copyValues, cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *, const int *,
+ const int *, cuComplex *, int *, int *, cusparseAction_t,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr, copyValues, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2csc(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cuDoubleComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, cuDoubleComplex *cscSortedVal,
+ int *cscSortedRowInd, int *cscSortedColPtr, cusparseAction_t copyValues,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *, const int *,
+ const int *, cuDoubleComplex *, int *, int *, cusparseAction_t,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr, copyValues, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSdense2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *A, int lda, const int *nnzPerRow, cusparseHybMat_t hybA,
+ int userEllWidth, cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *, int,
+ const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSdense2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth,
+ partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDdense2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *A, int lda, const int *nnzPerRow, cusparseHybMat_t hybA,
+ int userEllWidth, cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *, int,
+ const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDdense2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth,
+ partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCdense2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *A, int lda, const int *nnzPerRow, cusparseHybMat_t hybA,
+ int userEllWidth, cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ int, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdense2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth,
+ partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZdense2hyb(cusparseHandle_t handle, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *A,
+ int lda, const int *nnzPerRow, cusparseHybMat_t hybA,
+ int userEllWidth, cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, int, const int *, cusparseHybMat_t, int,
+ cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdense2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth,
+ partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseShyb2dense(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ float *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShyb2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDhyb2dense(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ double *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhyb2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseChyb2dense(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChyb2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZhyb2dense(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuDoubleComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhyb2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, cusparseHybMat_t, int,
+ cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseShyb2csr(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ float *csrSortedValA,
+ int *csrSortedRowPtrA,
+ int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShyb2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDhyb2csr(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ double *csrSortedValA,
+ int *csrSortedRowPtrA,
+ int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhyb2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseChyb2csr(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuComplex *csrSortedValA,
+ int *csrSortedRowPtrA,
+ int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChyb2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZhyb2csr(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuDoubleComplex *csrSortedValA,
+ int *csrSortedRowPtrA,
+ int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhyb2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsc2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsc2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsc2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsc2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsc2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsc2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsc2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, cusparseHybMat_t, int,
+ cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsc2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseShyb2csc(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ float *cscSortedVal,
+ int *cscSortedRowInd,
+ int *cscSortedColPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShyb2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDhyb2csc(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ double *cscSortedVal,
+ int *cscSortedRowInd,
+ int *cscSortedColPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhyb2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseChyb2csc(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuComplex *cscSortedVal,
+ int *cscSortedRowInd,
+ int *cscSortedColPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChyb2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZhyb2csc(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuDoubleComplex *cscSortedVal,
+ int *cscSortedRowInd,
+ int *cscSortedColPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhyb2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsr2bsrNnz(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, int blockDim, const cusparseMatDescr_t descrC,
+ int *bsrSortedRowPtrC, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const int *, const int *, int, const cusparseMatDescr_t, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsr2bsrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedRowPtrA,
+ csrSortedColIndA, blockDim, descrC, bsrSortedRowPtrC,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2bsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, float *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, const cusparseMatDescr_t,
+ float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2bsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, blockDim, descrC, bsrSortedValC,
+ bsrSortedRowPtrC, bsrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2bsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, double *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, const cusparseMatDescr_t,
+ double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2bsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, blockDim, descrC, bsrSortedValC,
+ bsrSortedRowPtrC, bsrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2bsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, cuComplex *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int,
+ const cusparseMatDescr_t, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2bsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, blockDim, descrC, bsrSortedValC,
+ bsrSortedRowPtrC, bsrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2bsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, cuDoubleComplex *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int,
+ const cusparseMatDescr_t, cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2bsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, blockDim, descrC, bsrSortedValC,
+ bsrSortedRowPtrC, bsrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, float *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, const cusparseMatDescr_t,
+ float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, blockDim, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, double *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, const cusparseMatDescr_t,
+ double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, blockDim, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, cuComplex *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int,
+ const cusparseMatDescr_t, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, blockDim, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, cuDoubleComplex *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int,
+ const cusparseMatDescr_t, cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, blockDim, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc_bufferSize(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const float *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const int *, const int *,
+ int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsc_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc_bufferSize(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const double *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const int *, const int *,
+ int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsc_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc_bufferSize(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *, const int *,
+ const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsc_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc_bufferSize(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *, const int *,
+ const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsc_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc_bufferSizeExt(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const float *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const int *, const int *,
+ int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSgebsr2gebsc_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc_bufferSizeExt(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const double *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const int *, const int *,
+ int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDgebsr2gebsc_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc_bufferSizeExt(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *, const int *,
+ const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCgebsr2gebsc_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc_bufferSizeExt(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *, const int *,
+ const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZgebsr2gebsc_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const float *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim, float *bscVal,
+ int *bscRowInd, int *bscColPtr, cusparseAction_t copyValues,
+ cusparseIndexBase_t baseIdx, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const int *, const int *,
+ int, int, float *, int *, int *, cusparseAction_t, cusparseIndexBase_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
+ bscColPtr, copyValues, baseIdx, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const double *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ double *bscVal, int *bscRowInd, int *bscColPtr, cusparseAction_t copyValues,
+ cusparseIndexBase_t baseIdx, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const int *, const int *,
+ int, int, double *, int *, int *, cusparseAction_t, cusparseIndexBase_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
+ bscColPtr, copyValues, baseIdx, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ cuComplex *bscVal, int *bscRowInd, int *bscColPtr,
+ cusparseAction_t copyValues, cusparseIndexBase_t baseIdx, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *, const int *,
+ const int *, int, int, cuComplex *, int *, int *, cusparseAction_t,
+ cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
+ bscColPtr, copyValues, baseIdx, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ cuDoubleComplex *bscVal, int *bscRowInd, int *bscColPtr,
+ cusparseAction_t copyValues, cusparseIndexBase_t baseIdx, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *, const int *,
+ const int *, int, int, cuDoubleComplex *, int *, int *, cusparseAction_t,
+ cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
+ bscColPtr, copyValues, baseIdx, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXgebsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, int rowBlockDim, int colBlockDim,
+ const cusparseMatDescr_t descrC, int *csrSortedRowPtrC,
+ int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const int *, const int *, int, int, const cusparseMatDescr_t, int *,
+ int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXgebsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
+ csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
+ int colBlockDim, const cusparseMatDescr_t descrC, float *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, int,
+ const cusparseMatDescr_t, float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
+ int colBlockDim, const cusparseMatDescr_t descrC, double *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, int,
+ const cusparseMatDescr_t, double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
+ int colBlockDim, const cusparseMatDescr_t descrC, cuComplex *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int, int,
+ const cusparseMatDescr_t, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
+ int colBlockDim, const cusparseMatDescr_t descrC,
+ cuDoubleComplex *csrSortedValC, int *csrSortedRowPtrC,
+ int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, int,
+ const cusparseMatDescr_t, cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseScsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDcsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCcsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZcsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsr2gebsrNnz(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrC,
+ int *bsrSortedRowPtrC, int rowBlockDim, int colBlockDim,
+ int *nnzTotalDevHostPtr, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const int *, const int *, const cusparseMatDescr_t, int *, int, int,
+ int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsr2gebsrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedRowPtrA,
+ csrSortedColIndA, descrC, bsrSortedRowPtrC, rowBlockDim,
+ colBlockDim, nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrC, float *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
+ int colBlockDim, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, const cusparseMatDescr_t,
+ float *, int *, int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrC, double *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
+ int colBlockDim, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, const cusparseMatDescr_t,
+ double *, int *, int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrC, cuComplex *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
+ int colBlockDim, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, const cusparseMatDescr_t,
+ cuComplex *, int *, int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrC, cuDoubleComplex *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
+ int colBlockDim, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cusparseMatDescr_t, cuDoubleComplex *, int *, int *, int, int,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const float *, const int *, const int *, int,
+ int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const double *, const int *, const int *, int,
+ int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ int, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, int, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const float *, const int *, const int *, int,
+ int, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSgebsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const double *, const int *, const int *, int,
+ int, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDgebsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ int, int, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCgebsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, int, int, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZgebsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXgebsr2gebsrNnz(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, int rowBlockDimA, int colBlockDimA,
+ const cusparseMatDescr_t descrC, int *bsrSortedRowPtrC, int rowBlockDimC,
+ int colBlockDimC, int *nnzTotalDevHostPtr, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const int *, const int *, int, int,
+ const cusparseMatDescr_t, int *, int, int, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXgebsr2gebsrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDimA, colBlockDimA, descrC,
+ bsrSortedRowPtrC, rowBlockDimC, colBlockDimC,
+ nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, const cusparseMatDescr_t descrC, float *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDimC,
+ int colBlockDimC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const float *, const int *, const int *, int,
+ int, const cusparseMatDescr_t, float *, int *, int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, const cusparseMatDescr_t descrC, double *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDimC,
+ int colBlockDimC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const double *, const int *, const int *, int,
+ int, const cusparseMatDescr_t, double *, int *, int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, const cusparseMatDescr_t descrC, cuComplex *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDimC,
+ int colBlockDimC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ int, int, const cusparseMatDescr_t, cuComplex *, int *, int *, int, int,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, const cusparseMatDescr_t descrC,
+ cuDoubleComplex *bsrSortedValC, int *bsrSortedRowPtrC,
+ int *bsrSortedColIndC, int rowBlockDimC, int colBlockDimC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, int, int, const cusparseMatDescr_t, cuDoubleComplex *, int *,
+ int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCreateIdentityPermutation(cusparseHandle_t handle, int n, int *p) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, int *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCreateIdentityPermutation");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, n, p);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcoosort_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, const int *cooRowsA,
+ const int *cooColsA, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const int *, const int *, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoosort_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, cooRowsA, cooColsA, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcoosortByRow(cusparseHandle_t handle,
+ int m, int n, int nnz,
+ int *cooRowsA, int *cooColsA,
+ int *P, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int *, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoosortByRow");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, cooRowsA, cooColsA, P, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcoosortByColumn(cusparseHandle_t handle,
+ int m, int n, int nnz,
+ int *cooRowsA,
+ int *cooColsA, int *P,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int *, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoosortByColumn");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, cooRowsA, cooColsA, P, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrsort_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, const int *csrRowPtrA,
+ const int *csrColIndA, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const int *, const int *, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrsort_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrRowPtrA, csrColIndA,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrsort(cusparseHandle_t handle, int m,
+ int n, int nnz,
+ const cusparseMatDescr_t descrA,
+ const int *csrRowPtrA,
+ int *csrColIndA, int *P,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const int *,
+ int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrsort");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrRowPtrA, csrColIndA, P,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcscsort_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, const int *cscColPtrA,
+ const int *cscRowIndA, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const int *, const int *, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcscsort_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, cscColPtrA, cscRowIndA,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcscsort(cusparseHandle_t handle, int m,
+ int n, int nnz,
+ const cusparseMatDescr_t descrA,
+ const int *cscColPtrA,
+ int *cscRowIndA, int *P,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const int *,
+ int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcscsort");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, cscColPtrA, cscRowIndA, P,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsru2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, float *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, float *, const int *, int *,
+ csru2csrInfo_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsru2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsru2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, double *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, double *, const int *, int *,
+ csru2csrInfo_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsru2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsru2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, cuComplex *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, cuComplex *, const int *, int *,
+ csru2csrInfo_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsru2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsru2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, cuDoubleComplex *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, cuDoubleComplex *, const int *, int *,
+ csru2csrInfo_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsru2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsru2csr(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, float *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, float *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsru2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsru2csr(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, double *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, double *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsru2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsru2csr(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, cuComplex *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsru2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsru2csr(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsru2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2csru(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, float *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, float *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2csru");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2csru(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, double *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, double *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2csru");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2csru(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, cuComplex *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2csru");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2csru(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2csru");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ const float *threshold, const cusparseMatDescr_t descrC,
+ const float *csrSortedValC, const int *csrSortedRowPtrC,
+ const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneDense2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ const double *threshold, const cusparseMatDescr_t descrC,
+ const double *csrSortedValC, const int *csrSortedRowPtrC,
+ const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneDense2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrNnz(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ const float *threshold, const cusparseMatDescr_t descrC, int *csrRowPtrC,
+ int *nnzTotalDevHostPtr, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, const float *,
+ const cusparseMatDescr_t, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneDense2csrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrRowPtrC,
+ nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrNnz(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ const double *threshold, const cusparseMatDescr_t descrC,
+ int *csrSortedRowPtrC, int *nnzTotalDevHostPtr, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, const double *,
+ const cusparseMatDescr_t, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneDense2csrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csr(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ const float *threshold, const cusparseMatDescr_t descrC,
+ float *csrSortedValC, const int *csrSortedRowPtrC, int *csrSortedColIndC,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, const float *,
+ const cusparseMatDescr_t, float *, const int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneDense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csr(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ const double *threshold, const cusparseMatDescr_t descrC,
+ double *csrSortedValC, const int *csrSortedRowPtrC, int *csrSortedColIndC,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, const double *,
+ const cusparseMatDescr_t, double *, const int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneDense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const float *threshold, const cusparseMatDescr_t descrC,
+ const float *csrSortedValC, const int *csrSortedRowPtrC,
+ const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, const float *, const cusparseMatDescr_t,
+ const float *, const int *, const int *, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneCsr2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, threshold, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const double *threshold, const cusparseMatDescr_t descrC,
+ const double *csrSortedValC, const int *csrSortedRowPtrC,
+ const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, const cusparseMatDescr_t,
+ const double *, const int *, const int *, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneCsr2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, threshold, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrNnz(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const float *threshold, const cusparseMatDescr_t descrC,
+ int *csrSortedRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, const float *, const cusparseMatDescr_t, int *,
+ int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, threshold, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrNnz(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const double *threshold, const cusparseMatDescr_t descrC,
+ int *csrSortedRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, const cusparseMatDescr_t, int *,
+ int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, threshold, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csr(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const float *threshold, const cusparseMatDescr_t descrC,
+ float *csrSortedValC, const int *csrSortedRowPtrC, int *csrSortedColIndC,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, const float *, const cusparseMatDescr_t,
+ float *, const int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneCsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, threshold, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csr(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const double *threshold, const cusparseMatDescr_t descrC,
+ double *csrSortedValC, const int *csrSortedRowPtrC, int *csrSortedColIndC,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, const cusparseMatDescr_t,
+ double *, const int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneCsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, threshold, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrByPercentage_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, const float *csrSortedValC,
+ const int *csrSortedRowPtrC, const int *csrSortedColIndC, pruneInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, float,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ pruneInfo_t, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneDense2csrByPercentage_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrByPercentage_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, const double *csrSortedValC,
+ const int *csrSortedRowPtrC, const int *csrSortedColIndC, pruneInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, float,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ pruneInfo_t, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneDense2csrByPercentage_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrNnzByPercentage(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, int *csrRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, float,
+ const cusparseMatDescr_t, int *, int *, pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneDense2csrNnzByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrRowPtrC,
+ nnzTotalDevHostPtr, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrNnzByPercentage(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, int *csrRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, float,
+ const cusparseMatDescr_t, int *, int *, pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneDense2csrNnzByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrRowPtrC,
+ nnzTotalDevHostPtr, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrByPercentage(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, float *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC, pruneInfo_t info,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, float,
+ const cusparseMatDescr_t, float *, const int *, int *, pruneInfo_t,
+ void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneDense2csrByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrByPercentage(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, double *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC, pruneInfo_t info,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, float,
+ const cusparseMatDescr_t, double *, const int *, int *, pruneInfo_t,
+ void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneDense2csrByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrByPercentage_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, const float *csrSortedValC,
+ const int *csrSortedRowPtrC, const int *csrSortedColIndC, pruneInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, float, const cusparseMatDescr_t, const float *,
+ const int *, const int *, pruneInfo_t, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrByPercentage_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, percentage, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrByPercentage_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, const double *csrSortedValC,
+ const int *csrSortedRowPtrC, const int *csrSortedColIndC, pruneInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, float, const cusparseMatDescr_t, const double *,
+ const int *, const int *, pruneInfo_t, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrByPercentage_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, percentage, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrNnzByPercentage(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, int *csrSortedRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, float, const cusparseMatDescr_t, int *, int *,
+ pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrNnzByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, percentage, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrNnzByPercentage(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, int *csrSortedRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, float, const cusparseMatDescr_t, int *, int *,
+ pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrNnzByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, percentage, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrByPercentage(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, float *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC, pruneInfo_t info,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, float, const cusparseMatDescr_t, float *,
+ const int *, int *, pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, percentage, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrByPercentage(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, double *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC, pruneInfo_t info,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, float, const cusparseMatDescr_t, double *,
+ const int *, int *, pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, percentage, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC, info, pBuffer);
+}
+
+} // extern "C"
diff --git a/tensorflow/stream_executor/cuda/cusparse_9_0.inc b/tensorflow/stream_executor/cuda/cusparse_9_0.inc
new file mode 100644
index 00000000000..2488823714a
--- /dev/null
+++ b/tensorflow/stream_executor/cuda/cusparse_9_0.inc
@@ -0,0 +1,7119 @@
+// Auto-generated, do not edit.
+
+extern "C" {
+
+cusparseStatus_t CUSPARSEAPI cusparseCreate(cusparseHandle_t *handle) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreate");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroy(cusparseHandle_t handle) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroy");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseGetVersion(cusparseHandle_t handle,
+ int *version) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetVersion");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, version);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseGetProperty(libraryPropertyType type,
+ int *value) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(libraryPropertyType, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetProperty");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(type, value);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSetStream(cusparseHandle_t handle,
+ cudaStream_t streamId) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, cudaStream_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetStream");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, streamId);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseGetStream(cusparseHandle_t handle,
+ cudaStream_t *streamId) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, cudaStream_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetStream");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, streamId);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseGetPointerMode(cusparseHandle_t handle, cusparsePointerMode_t *mode) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t,
+ cusparsePointerMode_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetPointerMode");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mode);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSetPointerMode(cusparseHandle_t handle, cusparsePointerMode_t mode) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, cusparsePointerMode_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetPointerMode");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mode);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCreateMatDescr(cusparseMatDescr_t *descrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateMatDescr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDestroyMatDescr(cusparseMatDescr_t descrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyMatDescr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCopyMatDescr(cusparseMatDescr_t dest, const cusparseMatDescr_t src) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t,
+ const cusparseMatDescr_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCopyMatDescr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(dest, src);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSetMatType(cusparseMatDescr_t descrA,
+ cusparseMatrixType_t type) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseMatrixType_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatType");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA, type);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSetMatFillMode(cusparseMatDescr_t descrA, cusparseFillMode_t fillMode) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseFillMode_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatFillMode");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA, fillMode);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSetMatDiagType(cusparseMatDescr_t descrA, cusparseDiagType_t diagType) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseDiagType_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatDiagType");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA, diagType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSetMatIndexBase(cusparseMatDescr_t descrA,
+ cusparseIndexBase_t base) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatIndexBase");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(descrA, base);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCreateSolveAnalysisInfo(cusparseSolveAnalysisInfo_t *info) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseSolveAnalysisInfo_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateSolveAnalysisInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDestroySolveAnalysisInfo(cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSolveAnalysisInfo_t);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDestroySolveAnalysisInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseGetLevelInfo(cusparseHandle_t handle, cusparseSolveAnalysisInfo_t info,
+ int *nlevels, int **levelPtr, int **levelInd) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseSolveAnalysisInfo_t, int *, int **, int **);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetLevelInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, nlevels, levelPtr, levelInd);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateCsrsv2Info(csrsv2Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrsv2Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsrsv2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrsv2Info(csrsv2Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrsv2Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsrsv2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateCsric02Info(csric02Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csric02Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsric02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyCsric02Info(csric02Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csric02Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsric02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateBsric02Info(bsric02Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsric02Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsric02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyBsric02Info(bsric02Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsric02Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsric02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateCsrilu02Info(csrilu02Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrilu02Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsrilu02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrilu02Info(csrilu02Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrilu02Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsrilu02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateBsrilu02Info(bsrilu02Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrilu02Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsrilu02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrilu02Info(bsrilu02Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrilu02Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsrilu02Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateBsrsv2Info(bsrsv2Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsv2Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsrsv2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrsv2Info(bsrsv2Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsv2Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsrsv2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateBsrsm2Info(bsrsm2Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsm2Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsrsm2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrsm2Info(bsrsm2Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsm2Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsrsm2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateHybMat(cusparseHybMat_t *hybA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHybMat_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateHybMat");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(hybA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyHybMat(cusparseHybMat_t hybA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHybMat_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyHybMat");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(hybA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateCsru2csrInfo(csru2csrInfo_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csru2csrInfo_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsru2csrInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyCsru2csrInfo(csru2csrInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csru2csrInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsru2csrInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCreateColorInfo(cusparseColorInfo_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateColorInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDestroyColorInfo(cusparseColorInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyColorInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSetColorAlgs(cusparseColorInfo_t info,
+ cusparseColorAlg_t alg) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t, cusparseColorAlg_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetColorAlgs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info, alg);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseGetColorAlgs(cusparseColorInfo_t info,
+ cusparseColorAlg_t *alg) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t,
+ cusparseColorAlg_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetColorAlgs");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info, alg);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreatePruneInfo(pruneInfo_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(pruneInfo_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreatePruneInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyPruneInfo(pruneInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(pruneInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyPruneInfo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSaxpyi(cusparseHandle_t handle, int nnz,
+ const float *alpha,
+ const float *xVal, const int *xInd,
+ float *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, const float *, const int *, float *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSaxpyi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDaxpyi(cusparseHandle_t handle, int nnz,
+ const double *alpha,
+ const double *xVal, const int *xInd,
+ double *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const double *, const int *,
+ double *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDaxpyi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCaxpyi(cusparseHandle_t handle, int nnz,
+ const cuComplex *alpha,
+ const cuComplex *xVal,
+ const int *xInd, cuComplex *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const cuComplex *, const int *,
+ cuComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCaxpyi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZaxpyi(cusparseHandle_t handle, int nnz,
+ const cuDoubleComplex *alpha,
+ const cuDoubleComplex *xVal,
+ const int *xInd, cuDoubleComplex *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
+ const int *, cuDoubleComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZaxpyi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSdoti(cusparseHandle_t handle, int nnz,
+ const float *xVal, const int *xInd,
+ const float *y,
+ float *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, const int *, const float *, float *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSdoti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDdoti(cusparseHandle_t handle, int nnz,
+ const double *xVal, const int *xInd,
+ const double *y,
+ double *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const int *, const double *,
+ double *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDdoti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCdoti(cusparseHandle_t handle, int nnz,
+ const cuComplex *xVal,
+ const int *xInd, const cuComplex *y,
+ cuComplex *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const int *, const cuComplex *,
+ cuComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdoti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZdoti(cusparseHandle_t handle, int nnz,
+ const cuDoubleComplex *xVal,
+ const int *xInd,
+ const cuDoubleComplex *y,
+ cuDoubleComplex *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const int *,
+ const cuDoubleComplex *, cuDoubleComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdoti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCdotci(cusparseHandle_t handle, int nnz,
+ const cuComplex *xVal,
+ const int *xInd, const cuComplex *y,
+ cuComplex *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const int *, const cuComplex *,
+ cuComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdotci");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZdotci(cusparseHandle_t handle, int nnz,
+ const cuDoubleComplex *xVal,
+ const int *xInd,
+ const cuDoubleComplex *y,
+ cuDoubleComplex *resultDevHostPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const int *,
+ const cuDoubleComplex *, cuDoubleComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdotci");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, resultDevHostPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgthr(cusparseHandle_t handle, int nnz,
+ const float *y, float *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, float *, const int *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgthr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgthr(cusparseHandle_t handle, int nnz,
+ const double *y, double *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, double *, const int *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgthr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgthr(cusparseHandle_t handle, int nnz,
+ const cuComplex *y, cuComplex *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, cuComplex *, const int *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgthr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgthr(cusparseHandle_t handle, int nnz,
+ const cuDoubleComplex *y,
+ cuDoubleComplex *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, cuDoubleComplex *,
+ const int *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgthr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgthrz(cusparseHandle_t handle, int nnz,
+ float *y, float *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, float *, float *,
+ const int *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgthrz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgthrz(cusparseHandle_t handle, int nnz,
+ double *y, double *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, double *, double *,
+ const int *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgthrz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgthrz(cusparseHandle_t handle, int nnz,
+ cuComplex *y, cuComplex *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cuComplex *, cuComplex *, const int *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgthrz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgthrz(cusparseHandle_t handle, int nnz,
+ cuDoubleComplex *y,
+ cuDoubleComplex *xVal,
+ const int *xInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, cuDoubleComplex *, cuDoubleComplex *, const int *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgthrz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSsctr(cusparseHandle_t handle, int nnz,
+ const float *xVal, const int *xInd,
+ float *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int,
+ const float *, const int *,
+ float *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSsctr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDsctr(cusparseHandle_t handle, int nnz,
+ const double *xVal, const int *xInd,
+ double *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const int *, double *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDsctr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsctr(cusparseHandle_t handle, int nnz,
+ const cuComplex *xVal,
+ const int *xInd, cuComplex *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const int *, cuComplex *,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsctr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZsctr(cusparseHandle_t handle, int nnz,
+ const cuDoubleComplex *xVal,
+ const int *xInd, cuDoubleComplex *y,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const int *,
+ cuDoubleComplex *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZsctr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSroti(cusparseHandle_t handle, int nnz,
+ float *xVal, const int *xInd,
+ float *y, const float *c,
+ const float *s,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, float *, const int *, float *, const float *,
+ const float *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSroti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, c, s, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDroti(cusparseHandle_t handle, int nnz,
+ double *xVal, const int *xInd,
+ double *y, const double *c,
+ const double *s,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, double *, const int *, double *, const double *,
+ const double *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDroti");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, nnz, xVal, xInd, y, c, s, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSgemvi(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, const float *alpha, /* host or device pointer */
+ const float *A, int lda, int nnz, const float *xVal,
+ const int *xInd, const float *beta, /* host or device pointer */
+ float *y, cusparseIndexBase_t idxBase, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const float *,
+ const float *, int, int, const float *, const int *, const float *,
+ float *, cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgemvi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
+ idxBase, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
+ int m, int n, int nnz, int *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgemvi_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDgemvi(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, const double *alpha, /* host or device pointer */
+ const double *A, int lda, int nnz, const double *xVal,
+ const int *xInd, const double *beta, /* host or device pointer */
+ double *y, cusparseIndexBase_t idxBase, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const double *,
+ const double *, int, int, const double *, const int *, const double *,
+ double *, cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgemvi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
+ idxBase, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
+ int m, int n, int nnz, int *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgemvi_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgemvi(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const cuComplex *alpha, /* host or device pointer */
+ const cuComplex *A, int lda, int nnz, const cuComplex *xVal,
+ const int *xInd, const cuComplex *beta, /* host or device pointer */
+ cuComplex *y, cusparseIndexBase_t idxBase, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuComplex *,
+ const cuComplex *, int, int, const cuComplex *, const int *,
+ const cuComplex *, cuComplex *, cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgemvi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
+ idxBase, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
+ int m, int n, int nnz, int *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgemvi_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgemvi(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const cuDoubleComplex *alpha, /* host or device pointer */
+ const cuDoubleComplex *A, int lda, int nnz, const cuDoubleComplex *xVal,
+ const int *xInd, const cuDoubleComplex *beta, /* host or device pointer */
+ cuDoubleComplex *y, cusparseIndexBase_t idxBase, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, int, int, const cuDoubleComplex *, const int *,
+ const cuDoubleComplex *, cuDoubleComplex *, cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgemvi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
+ idxBase, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
+ int m, int n, int nnz, int *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgemvi_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrmv(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int nnz,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *x, const float *beta, float *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ const float *, const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDcsrmv(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, int nnz, const double *alpha,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const double *x, const double *beta, double *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ const double *, const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCcsrmv(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, int nnz, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cuComplex *x, const cuComplex *beta, cuComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ const cuComplex *, const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrmv(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int nnz,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *x,
+ const cuDoubleComplex *beta, cuDoubleComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int,
+ const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsrmvEx_bufferSize(
+ cusparseHandle_t handle, cusparseAlgMode_t alg, cusparseOperation_t transA,
+ int m, int n, int nnz, const void *alpha, cudaDataType alphatype,
+ const cusparseMatDescr_t descrA, const void *csrValA,
+ cudaDataType csrValAtype, const int *csrRowPtrA, const int *csrColIndA,
+ const void *x, cudaDataType xtype, const void *beta, cudaDataType betatype,
+ void *y, cudaDataType ytype, cudaDataType executiontype,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseAlgMode_t, cusparseOperation_t, int, int, int,
+ const void *, cudaDataType, const cusparseMatDescr_t, const void *,
+ cudaDataType, const int *, const int *, const void *, cudaDataType,
+ const void *, cudaDataType, void *, cudaDataType, cudaDataType, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrmvEx_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, alg, transA, m, n, nnz, alpha, alphatype, descrA,
+ csrValA, csrValAtype, csrRowPtrA, csrColIndA, x, xtype, beta,
+ betatype, y, ytype, executiontype, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsrmvEx(
+ cusparseHandle_t handle, cusparseAlgMode_t alg, cusparseOperation_t transA,
+ int m, int n, int nnz, const void *alpha, cudaDataType alphatype,
+ const cusparseMatDescr_t descrA, const void *csrValA,
+ cudaDataType csrValAtype, const int *csrRowPtrA, const int *csrColIndA,
+ const void *x, cudaDataType xtype, const void *beta, cudaDataType betatype,
+ void *y, cudaDataType ytype, cudaDataType executiontype, void *buffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseAlgMode_t, cusparseOperation_t, int, int, int,
+ const void *, cudaDataType, const cusparseMatDescr_t, const void *,
+ cudaDataType, const int *, const int *, const void *, cudaDataType,
+ const void *, cudaDataType, void *, cudaDataType, cudaDataType, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrmvEx");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, alg, transA, m, n, nnz, alpha, alphatype, descrA,
+ csrValA, csrValAtype, csrRowPtrA, csrColIndA, x, xtype, beta,
+ betatype, y, ytype, executiontype, buffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrmv_mp(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int nnz,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *x, const float *beta, float *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ const float *, const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrmv_mp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDcsrmv_mp(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, int nnz, const double *alpha,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const double *x, const double *beta, double *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ const double *, const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrmv_mp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrmv_mp(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int nnz,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuComplex *x, const cuComplex *beta,
+ cuComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ const cuComplex *, const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrmv_mp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrmv_mp(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int nnz,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *x,
+ const cuDoubleComplex *beta, cuDoubleComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int,
+ const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrmv_mp");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseShybmv(
+ cusparseHandle_t handle, cusparseOperation_t transA, const float *alpha,
+ const cusparseMatDescr_t descrA, const cusparseHybMat_t hybA,
+ const float *x, const float *beta, float *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const float *,
+ const cusparseMatDescr_t, const cusparseHybMat_t, const float *,
+ const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShybmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, alpha, descrA, hybA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDhybmv(
+ cusparseHandle_t handle, cusparseOperation_t transA, const double *alpha,
+ const cusparseMatDescr_t descrA, const cusparseHybMat_t hybA,
+ const double *x, const double *beta, double *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const double *,
+ const cusparseMatDescr_t, const cusparseHybMat_t, const double *,
+ const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhybmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, alpha, descrA, hybA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseChybmv(
+ cusparseHandle_t handle, cusparseOperation_t transA, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, const cusparseHybMat_t hybA,
+ const cuComplex *x, const cuComplex *beta, cuComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cuComplex *,
+ const cusparseMatDescr_t, const cusparseHybMat_t, const cuComplex *,
+ const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChybmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, alpha, descrA, hybA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZhybmv(cusparseHandle_t handle, cusparseOperation_t transA,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA, const cuDoubleComplex *x,
+ const cuDoubleComplex *beta, cuDoubleComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cusparseHybMat_t, const cuDoubleComplex *,
+ const cuDoubleComplex *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhybmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, alpha, descrA, hybA, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrmv(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nb, int nnzb, const float *alpha,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const float *x, const float *beta, float *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ const float *, const cusparseMatDescr_t, const float *, const int *,
+ const int *, int, const float *, const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
+ x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrmv(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nb, int nnzb, const double *alpha,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const double *x, const double *beta, double *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ const double *, const cusparseMatDescr_t, const double *, const int *,
+ const int *, int, const double *, const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
+ x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCbsrmv(cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nb, int nnzb,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *bsrSortedValA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, int blockDim, const cuComplex *x,
+ const cuComplex *beta, cuComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, int, const cuComplex *, const cuComplex *,
+ cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
+ x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrmv(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nb, int nnzb,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *bsrSortedValA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, int blockDim, const cuDoubleComplex *x,
+ const cuDoubleComplex *beta, cuDoubleComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
+ x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSbsrxmv(cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int sizeOfMask, int mb, int nb,
+ int nnzb, const float *alpha, const cusparseMatDescr_t descrA,
+ const float *bsrSortedValA, const int *bsrSortedMaskPtrA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
+ const int *bsrSortedColIndA, int blockDim, const float *x,
+ const float *beta, float *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ int, const float *, const cusparseMatDescr_t, const float *, const int *,
+ const int *, const int *, const int *, int, const float *, const float *,
+ float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrxmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
+ bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDbsrxmv(cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int sizeOfMask, int mb, int nb,
+ int nnzb, const double *alpha, const cusparseMatDescr_t descrA,
+ const double *bsrSortedValA, const int *bsrSortedMaskPtrA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
+ const int *bsrSortedColIndA, int blockDim, const double *x,
+ const double *beta, double *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ int, const double *, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const int *, const int *, int, const double *,
+ const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrxmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
+ bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrxmv(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int sizeOfMask, int mb, int nb, int nnzb,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *bsrSortedValA, const int *bsrSortedMaskPtrA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
+ const int *bsrSortedColIndA, int blockDim, const cuComplex *x,
+ const cuComplex *beta, cuComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ int, const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, const int *, const int *, int,
+ const cuComplex *, const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrxmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
+ bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrxmv(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int sizeOfMask, int mb, int nb, int nnzb,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *bsrSortedValA, const int *bsrSortedMaskPtrA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
+ const int *bsrSortedColIndA, int blockDim, const cuDoubleComplex *x,
+ const cuDoubleComplex *beta, cuDoubleComplex *y) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
+ int, const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, const int *,
+ const int *, int, const cuDoubleComplex *, const cuDoubleComplex *,
+ cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrxmv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
+ bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsrsv_analysisEx(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const void *csrSortedValA,
+ cudaDataType csrSortedValAtype, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ cudaDataType executiontype) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const void *, cudaDataType, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, cudaDataType);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrsv_analysisEx");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedValAtype, csrSortedRowPtrA, csrSortedColIndA, info,
+ executiontype);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsrsv_solveEx(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ const void *alpha, cudaDataType alphatype, const cusparseMatDescr_t descrA,
+ const void *csrSortedValA, cudaDataType csrSortedValAtype,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info, const void *f, cudaDataType ftype,
+ void *x, cudaDataType xtype, cudaDataType executiontype) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const void *, cudaDataType,
+ const cusparseMatDescr_t, const void *, cudaDataType, const int *,
+ const int *, cusparseSolveAnalysisInfo_t, const void *, cudaDataType,
+ void *, cudaDataType, cudaDataType);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrsv_solveEx");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, alpha, alphatype, descrA, csrSortedValA,
+ csrSortedValAtype, csrSortedRowPtrA, csrSortedColIndA, info,
+ f, ftype, x, xtype, executiontype);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const float *f, float *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const double *f, double *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const cuComplex *f, cuComplex *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const cuDoubleComplex *f, cuDoubleComplex *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, cusparseSolveAnalysisInfo_t, const cuDoubleComplex *,
+ cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrsv2_zeroPivot(cusparseHandle_t handle,
+ csrsv2Info_t info,
+ int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, csrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrsv2_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, csrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, csrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, csrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, csrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, csrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, csrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, csrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, csrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, csrsv2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, csrsv2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, csrsv2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, csrsv2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrsv2Info_t info, const float *f, float *x,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ csrsv2Info_t, const float *, float *, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrsv2Info_t info, const double *f, double *x,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ csrsv2Info_t, const double *, double *, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrsv2Info_t info, const cuComplex *f,
+ cuComplex *x, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ csrsv2Info_t, const cuComplex *, cuComplex *, cusparseSolvePolicy_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrsv2Info_t info, const cuDoubleComplex *f,
+ cuDoubleComplex *x, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, csrsv2Info_t, const cuDoubleComplex *, cuDoubleComplex *,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXbsrsv2_zeroPivot(cusparseHandle_t handle,
+ bsrsv2Info_t info,
+ int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsrsv2_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, float *, const int *, const int *, int,
+ bsrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, double *, const int *, const int *, int,
+ bsrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, cuComplex *, const int *, const int *, int,
+ bsrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, cuDoubleComplex *, const int *, const int *,
+ int, bsrsv2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
+ bsrsv2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, float *, const int *, const int *, int,
+ bsrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
+ pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
+ bsrsv2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, double *, const int *, const int *, int,
+ bsrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
+ pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
+ bsrsv2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, cuComplex *, const int *, const int *, int,
+ bsrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
+ pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
+ bsrsv2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, cuDoubleComplex *, const int *, const int *,
+ int, bsrsv2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
+ pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, const float *, const int *, const int *, int,
+ bsrsv2Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, const double *, const int *, const int *, int,
+ bsrsv2Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ int, bsrsv2Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, int, bsrsv2Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb, const float *alpha,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, const float *f, float *x, cusparseSolvePolicy_t policy,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const float *, const cusparseMatDescr_t, const float *, const int *,
+ const int *, int, bsrsv2Info_t, const float *, float *,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
+ policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb, const double *alpha,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, const double *f, double *x, cusparseSolvePolicy_t policy,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const double *, const cusparseMatDescr_t, const double *, const int *,
+ const int *, int, bsrsv2Info_t, const double *, double *,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
+ policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, const cuComplex *f, cuComplex *x,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, int, bsrsv2Info_t, const cuComplex *,
+ cuComplex *, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
+ policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, int mb, int nnzb, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ bsrsv2Info_t info, const cuDoubleComplex *f, cuDoubleComplex *x,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
+ const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, bsrsv2Info_t,
+ const cuDoubleComplex *, cuDoubleComplex *, cusparseSolvePolicy_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
+ policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseShybsv_analysis(cusparseHandle_t handle, cusparseOperation_t transA,
+ const cusparseMatDescr_t descrA, cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cusparseMatDescr_t,
+ cusparseHybMat_t, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShybsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, descrA, hybA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDhybsv_analysis(cusparseHandle_t handle, cusparseOperation_t transA,
+ const cusparseMatDescr_t descrA, cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cusparseMatDescr_t,
+ cusparseHybMat_t, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhybsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, descrA, hybA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseChybsv_analysis(cusparseHandle_t handle, cusparseOperation_t transA,
+ const cusparseMatDescr_t descrA, cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cusparseMatDescr_t,
+ cusparseHybMat_t, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChybsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, descrA, hybA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZhybsv_analysis(cusparseHandle_t handle, cusparseOperation_t transA,
+ const cusparseMatDescr_t descrA, cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cusparseMatDescr_t,
+ cusparseHybMat_t, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhybsv_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, descrA, hybA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseShybsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t trans, const float *alpha,
+ const cusparseMatDescr_t descra, const cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info, const float *f, float *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const float *,
+ const cusparseMatDescr_t, const cusparseHybMat_t,
+ cusparseSolveAnalysisInfo_t, const float *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShybsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, alpha, descra, hybA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseChybsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t trans, const cuComplex *alpha,
+ const cusparseMatDescr_t descra, const cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info, const cuComplex *f, cuComplex *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cuComplex *,
+ const cusparseMatDescr_t, const cusparseHybMat_t,
+ cusparseSolveAnalysisInfo_t, const cuComplex *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChybsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, alpha, descra, hybA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDhybsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t trans, const double *alpha,
+ const cusparseMatDescr_t descra, const cusparseHybMat_t hybA,
+ cusparseSolveAnalysisInfo_t info, const double *f, double *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const double *,
+ const cusparseMatDescr_t, const cusparseHybMat_t,
+ cusparseSolveAnalysisInfo_t, const double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhybsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, alpha, descra, hybA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZhybsv_solve(
+ cusparseHandle_t handle, cusparseOperation_t trans,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descra,
+ const cusparseHybMat_t hybA, cusparseSolveAnalysisInfo_t info,
+ const cuDoubleComplex *f, cuDoubleComplex *x) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cusparseHybMat_t,
+ cusparseSolveAnalysisInfo_t, const cuDoubleComplex *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhybsv_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, alpha, descra, hybA, info, f, x);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseScsrmm(cusparseHandle_t handle, cusparseOperation_t transA, int m,
+ int n, int k, int nnz, const float *alpha,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const float *B, int ldb, const float *beta, float *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ const float *, int, const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, k, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrmm(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int k,
+ int nnz, const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const double *B, int ldb, const double *beta,
+ double *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ const double *, int, const double *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, k, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrmm(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int k,
+ int nnz, const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuComplex *B, int ldb,
+ const cuComplex *beta, cuComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int,
+ const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, const cuComplex *, int, const cuComplex *,
+ cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, k, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrmm(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n, int k,
+ int nnz, const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *B, int ldb,
+ const cuDoubleComplex *beta, cuDoubleComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, int, int,
+ const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, k, nnz, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseScsrmm2(cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k, int nnz,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *B, int ldb,
+ const float *beta, float *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ int, const float *, const cusparseMatDescr_t, const float *, const int *,
+ const int *, const float *, int, const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrmm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDcsrmm2(cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k, int nnz,
+ const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const double *B, int ldb,
+ const double *beta, double *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ int, const double *, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, int, const double *, double *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrmm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCcsrmm2(cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k, int nnz,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuComplex *B, int ldb,
+ const cuComplex *beta, cuComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ int, const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, const cuComplex *, int, const cuComplex *,
+ cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrmm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrmm2(
+ cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k, int nnz,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *B, int ldb,
+ const cuDoubleComplex *beta, cuDoubleComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ int, const cuDoubleComplex *, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrmm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, nnz, alpha, descrA,
+ csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
+ beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrmm(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int kb, int nnzb, const float *alpha, const cusparseMatDescr_t descrA,
+ const float *bsrSortedValA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, const int blockSize, const float *B,
+ const int ldb, const float *beta, float *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ const int, const float *, const int, const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
+ B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrmm(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int kb, int nnzb, const double *alpha, const cusparseMatDescr_t descrA,
+ const double *bsrSortedValA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, const int blockSize, const double *B,
+ const int ldb, const double *beta, double *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ const int, const double *, const int, const double *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
+ B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrmm(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int kb, int nnzb, const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *bsrSortedValA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, const int blockSize, const cuComplex *B,
+ const int ldb, const cuComplex *beta, cuComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ const int, const cuComplex *, const int, const cuComplex *, cuComplex *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
+ B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrmm(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int kb, int nnzb, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA,
+ const int blockSize, const cuDoubleComplex *B, const int ldb,
+ const cuDoubleComplex *beta, cuDoubleComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, const int, const cuDoubleComplex *, const int,
+ const cuDoubleComplex *, cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrmm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
+ bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
+ B, ldb, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgemmi(
+ cusparseHandle_t handle, int m, int n, int k, int nnz,
+ const float *alpha, /* host or device pointer */
+ const float *A, int lda, const float *cscValB, const int *cscColPtrB,
+ const int *cscRowIndB, const float *beta, /* host or device pointer */
+ float *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int, const float *, const float *, int,
+ const float *, const int *, const int *, const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgemmi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
+ cscRowIndB, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgemmi(
+ cusparseHandle_t handle, int m, int n, int k, int nnz,
+ const double *alpha, /* host or device pointer */
+ const double *A, int lda, const double *cscValB, const int *cscColPtrB,
+ const int *cscRowIndB, const double *beta, /* host or device pointer */
+ double *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int, const double *, const double *, int,
+ const double *, const int *, const int *, const double *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgemmi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
+ cscRowIndB, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCgemmi(cusparseHandle_t handle, int m, int n, int k, int nnz,
+ const cuComplex *alpha, /* host or device pointer */
+ const cuComplex *A, int lda, const cuComplex *cscValB,
+ const int *cscColPtrB, const int *cscRowIndB,
+ const cuComplex *beta, /* host or device pointer */
+ cuComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int, const cuComplex *,
+ const cuComplex *, int, const cuComplex *, const int *, const int *,
+ const cuComplex *, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgemmi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
+ cscRowIndB, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgemmi(
+ cusparseHandle_t handle, int m, int n, int k, int nnz,
+ const cuDoubleComplex *alpha, /* host or device pointer */
+ const cuDoubleComplex *A, int lda, const cuDoubleComplex *cscValB,
+ const int *cscColPtrB, const int *cscRowIndB,
+ const cuDoubleComplex *beta, /* host or device pointer */
+ cuDoubleComplex *C, int ldc) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, int, const cuDoubleComplex *, const int *,
+ const int *, const cuDoubleComplex *, cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgemmi");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
+ cscRowIndB, beta, C, ldc);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsm_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsm_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsm_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsm_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsm_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsm_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsm_analysis(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsm_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrsm_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const float *alpha, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const float *F, int ldf, float *X, int ldx) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const float *, int, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsm_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, F, ldf, X, ldx);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrsm_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const double *alpha, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const double *F, int ldf, double *X, int ldx) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const double *, int, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsm_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, F, ldf, X, ldx);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrsm_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const cuComplex *F, int ldf, cuComplex *X, int ldx) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, const cuComplex *, int, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsm_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, F, ldf, X, ldx);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrsm_solve(
+ cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
+ const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseSolveAnalysisInfo_t info,
+ const cuDoubleComplex *F, int ldf, cuDoubleComplex *X, int ldx) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, cusparseSolveAnalysisInfo_t, const cuDoubleComplex *, int,
+ cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsm_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, m, n, alpha, descrA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, info, F, ldf, X, ldx);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXbsrsm2_zeroPivot(cusparseHandle_t handle,
+ bsrsm2Info_t info,
+ int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsrsm2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsrsm2_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, int, bsrsm2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, int, bsrsm2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, int, bsrsm2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrsm2Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, int, bsrsm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, int, bsrsm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, int, bsrsm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrsm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, const float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, bsrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, const double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, bsrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA, const cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int, bsrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, bsrsm2Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const float *alpha, const cusparseMatDescr_t descrA,
+ const float *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
+ const float *F, int ldf, float *X, int ldx, cusparseSolvePolicy_t policy,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *, int,
+ bsrsm2Info_t, const float *, int, float *, int, cusparseSolvePolicy_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, F, ldf, X, ldx, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const double *alpha, const cusparseMatDescr_t descrA,
+ const double *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
+ const double *F, int ldf, double *X, int ldx, cusparseSolvePolicy_t policy,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *, int,
+ bsrsm2Info_t, const double *, int, double *, int, cusparseSolvePolicy_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, F, ldf, X, ldx, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cuComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
+ const cuComplex *F, int ldf, cuComplex *X, int ldx,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ int, bsrsm2Info_t, const cuComplex *, int, cuComplex *, int,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, F, ldf, X, ldx, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_solve(
+ cusparseHandle_t handle, cusparseDirection_t dirA,
+ cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
+ int nnzb, const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
+ const cuDoubleComplex *F, int ldf, cuDoubleComplex *X, int ldx,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
+ cusparseOperation_t, int, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, int, bsrsm2Info_t, const cuDoubleComplex *, int,
+ cuDoubleComplex *, int, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_solve");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
+ bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
+ info, F, ldf, X, ldx, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsrilu0Ex(
+ cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, void *csrSortedValA_ValM,
+ cudaDataType csrSortedValA_ValMtype,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info, cudaDataType executiontype) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ void *, cudaDataType, const int *, const int *,
+ cusparseSolveAnalysisInfo_t, cudaDataType);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrilu0Ex");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedValA_ValMtype, csrSortedRowPtrA, csrSortedColIndA,
+ info, executiontype);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseScsrilu0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, float *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDcsrilu0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, double *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCcsrilu0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, cuComplex *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu0(
+ cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_numericBoost(
+ cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
+ float *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, csrilu02Info_t, int, double *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_numericBoost(
+ cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
+ double *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, csrilu02Info_t, int, double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_numericBoost(
+ cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
+ cuComplex *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, csrilu02Info_t, int, double *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_numericBoost(
+ cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
+ cuDoubleComplex *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, csrilu02Info_t, int, double *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrilu02_zeroPivot(
+ cusparseHandle_t handle, csrilu02Info_t info, int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, csrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrilu02_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedVal, const int *csrSortedRowPtr, const int *csrSortedColInd,
+ csrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csrilu02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, csrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrilu02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_numericBoost(
+ cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
+ float *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, bsrilu02Info_t, int, double *, float *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_numericBoost(
+ cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
+ double *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, bsrilu02Info_t, int, double *, double *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_numericBoost(
+ cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
+ cuComplex *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, bsrilu02Info_t, int, double *, cuComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_numericBoost(
+ cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
+ cuDoubleComplex *boost_val) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, bsrilu02Info_t, int, double *, cuDoubleComplex *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_numericBoost");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, enable_boost, tol, boost_val);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXbsrilu02_zeroPivot(
+ cusparseHandle_t handle, bsrilu02Info_t info, int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsrilu02_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsrilu02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsrilu02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t,
+ size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descra, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descra, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descra, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descra, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descra, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descra, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descra, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descra, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseScsric0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, float *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDcsric0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, double *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCcsric0(cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, cuComplex *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsric0(
+ cusparseHandle_t handle, cusparseOperation_t trans, int m,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrSortedValA_ValM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ cusparseSolveAnalysisInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, cusparseSolveAnalysisInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric0");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, trans, m, descrA, csrSortedValA_ValM,
+ csrSortedRowPtrA, csrSortedColIndA, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsric02_zeroPivot(cusparseHandle_t handle,
+ csric02Info_t info,
+ int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, csric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsric02_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsric02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsric02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsric02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsric02_bufferSize(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsric02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedVal, const int *csrSortedRowPtr, const int *csrSortedColInd,
+ csric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsric02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsric02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsric02_bufferSizeExt(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, csric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsric02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsric02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsric02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsric02_analysis(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, csric02Info_t info,
+ cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, csric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsric02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ float *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsric02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ double *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsric02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuComplex *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsric02(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ cuDoubleComplex *csrSortedValA_valM,
+ /* matrix A values are updated inplace
+ to be the preconditioner M values */
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ csric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
+ csrSortedColIndA, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXbsric02_zeroPivot(cusparseHandle_t handle,
+ bsric02Info_t info,
+ int *position) {
+ using FuncPtr =
+ cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsric02_zeroPivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, info, position);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsric02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsric02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsric02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsric02_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsric02Info_t, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsric02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsric02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsric02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsric02Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsric02_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
+ bsric02Info_t info, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsric02Info_t,
+ size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockSize, info, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsric02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pInputBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsric02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pInputBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsric02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pInputBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsric02_analysis(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02_analysis");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pInputBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsric02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, float *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ float *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsric02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, double *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ double *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsric02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuComplex *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsric02(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
+ const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
+ bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, const int *, int, bsric02Info_t,
+ cusparseSolvePolicy_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, blockDim, info, policy, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv(cusparseHandle_t handle, int m,
+ int n, const float *dl,
+ const float *d, const float *du,
+ float *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, int,
+ const float *, const float *,
+ const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv(cusparseHandle_t handle, int m,
+ int n, const double *dl,
+ const double *d, const double *du,
+ double *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv(cusparseHandle_t handle, int m,
+ int n, const cuComplex *dl,
+ const cuComplex *d,
+ const cuComplex *du, cuComplex *B,
+ int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv(cusparseHandle_t handle, int m,
+ int n, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d,
+ const cuDoubleComplex *du,
+ cuDoubleComplex *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const float *dl, const float *d,
+ const float *du, const float *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const float *, const float *,
+ const float *, int, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const double *dl, const double *d,
+ const double *du, const double *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, const double *, int, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const cuComplex *dl,
+ const cuComplex *d, const cuComplex *du, const cuComplex *B, int ldb,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, const cuComplex *, int, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du,
+ const cuDoubleComplex *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, const cuDoubleComplex *,
+ int, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2(cusparseHandle_t handle, int m,
+ int n, const float *dl,
+ const float *d, const float *du,
+ float *B, int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const float *, const float *,
+ float *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv2(cusparseHandle_t handle, int m,
+ int n, const double *dl,
+ const double *d, const double *du,
+ double *B, int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, double *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2(cusparseHandle_t handle, int m,
+ int n, const cuComplex *dl,
+ const cuComplex *d,
+ const cuComplex *du, cuComplex *B,
+ int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2(cusparseHandle_t handle, int m,
+ int n, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d,
+ const cuDoubleComplex *du,
+ cuDoubleComplex *B, int ldb,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *, int,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSgtsv_nopivot(cusparseHandle_t handle, int m, int n, const float *dl,
+ const float *d, const float *du, float *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, int,
+ const float *, const float *,
+ const float *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDgtsv_nopivot(cusparseHandle_t handle, int m, int n, const double *dl,
+ const double *d, const double *du, double *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv_nopivot(
+ cusparseHandle_t handle, int m, int n, const cuComplex *dl,
+ const cuComplex *d, const cuComplex *du, cuComplex *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZgtsv_nopivot(cusparseHandle_t handle, int m, int n,
+ const cuDoubleComplex *dl, const cuDoubleComplex *d,
+ const cuDoubleComplex *du, cuDoubleComplex *B, int ldb) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_nopivot_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const float *dl, const float *d,
+ const float *du, const float *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const float *, const float *,
+ const float *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSgtsv2_nopivot_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_nopivot_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const double *dl, const double *d,
+ const double *du, const double *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, const double *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDgtsv2_nopivot_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_nopivot_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const cuComplex *dl,
+ const cuComplex *d, const cuComplex *du, const cuComplex *B, int ldb,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, const cuComplex *, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCgtsv2_nopivot_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_nopivot_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du,
+ const cuDoubleComplex *B, int ldb, size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, const cuDoubleComplex *,
+ int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZgtsv2_nopivot_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_nopivot(
+ cusparseHandle_t handle, int m, int n, const float *dl, const float *d,
+ const float *du, float *B, int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const float *, const float *,
+ float *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_nopivot(
+ cusparseHandle_t handle, int m, int n, const double *dl, const double *d,
+ const double *du, double *B, int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const double *,
+ const double *, double *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_nopivot(
+ cusparseHandle_t handle, int m, int n, const cuComplex *dl,
+ const cuComplex *d, const cuComplex *du, cuComplex *B, int ldb,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_nopivot(
+ cusparseHandle_t handle, int m, int n, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du, cuDoubleComplex *B,
+ int ldb, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *, int,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2_nopivot");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsvStridedBatch(
+ cusparseHandle_t handle, int m, const float *dl, const float *d,
+ const float *du, float *x, int batchCount, int batchStride) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, const float *, const float *,
+ float *, int, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsvStridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsvStridedBatch(
+ cusparseHandle_t handle, int m, const double *dl, const double *d,
+ const double *du, double *x, int batchCount, int batchStride) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const double *, const double *,
+ double *, int, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsvStridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsvStridedBatch(
+ cusparseHandle_t handle, int m, const cuComplex *dl, const cuComplex *d,
+ const cuComplex *du, cuComplex *x, int batchCount, int batchStride) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsvStridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsvStridedBatch(
+ cusparseHandle_t handle, int m, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du, cuDoubleComplex *x,
+ int batchCount, int batchStride) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
+ const cuDoubleComplex *, cuDoubleComplex *, int, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsvStridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2StridedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int m, const float *dl, const float *d,
+ const float *du, const float *x, int batchCount, int batchStride,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, const float *, const float *,
+ const float *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSgtsv2StridedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
+ bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgtsv2StridedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int m, const double *dl, const double *d,
+ const double *du, const double *x, int batchCount, int batchStride,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const double *, const double *,
+ const double *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDgtsv2StridedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
+ bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2StridedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int m, const cuComplex *dl, const cuComplex *d,
+ const cuComplex *du, const cuComplex *x, int batchCount, int batchStride,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, const cuComplex *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCgtsv2StridedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
+ bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2StridedBatch_bufferSizeExt(
+ cusparseHandle_t handle, int m, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du,
+ const cuDoubleComplex *x, int batchCount, int batchStride,
+ size_t *bufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
+ const cuDoubleComplex *, const cuDoubleComplex *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZgtsv2StridedBatch_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
+ bufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgtsv2StridedBatch(
+ cusparseHandle_t handle, int m, const float *dl, const float *d,
+ const float *du, float *x, int batchCount, int batchStride, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const float *, const float *, const float *,
+ float *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2StridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDgtsv2StridedBatch(cusparseHandle_t handle, int m, const double *dl,
+ const double *d, const double *du, double *x,
+ int batchCount, int batchStride, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const double *, const double *, const double *,
+ double *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2StridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgtsv2StridedBatch(
+ cusparseHandle_t handle, int m, const cuComplex *dl, const cuComplex *d,
+ const cuComplex *du, cuComplex *x, int batchCount, int batchStride,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuComplex *, const cuComplex *,
+ const cuComplex *, cuComplex *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2StridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgtsv2StridedBatch(
+ cusparseHandle_t handle, int m, const cuDoubleComplex *dl,
+ const cuDoubleComplex *d, const cuDoubleComplex *du, cuDoubleComplex *x,
+ int batchCount, int batchStride, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
+ const cuDoubleComplex *, cuDoubleComplex *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2StridedBatch");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseXcsrgemmNnz(cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k,
+ const cusparseMatDescr_t descrA, const int nnzA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, const int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, int *csrSortedRowPtrC,
+ int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ const cusparseMatDescr_t, const int, const int *, const int *,
+ const cusparseMatDescr_t, const int, const int *, const int *,
+ const cusparseMatDescr_t, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrgemmNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, descrA, nnzA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrgemm(
+ cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k,
+ const cusparseMatDescr_t descrA, const int nnzA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, const int nnzB, const float *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, float *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ const cusparseMatDescr_t, const int, const float *, const int *,
+ const int *, const cusparseMatDescr_t, const int, const float *,
+ const int *, const int *, const cusparseMatDescr_t, float *, const int *,
+ int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgemm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrgemm(
+ cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k,
+ const cusparseMatDescr_t descrA, int nnzA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const double *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, double *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ const cusparseMatDescr_t, int, const double *, const int *, const int *,
+ const cusparseMatDescr_t, int, const double *, const int *, const int *,
+ const cusparseMatDescr_t, double *, const int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgemm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrgemm(
+ cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k,
+ const cusparseMatDescr_t descrA, int nnzA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const cuComplex *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, cuComplex *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ const cusparseMatDescr_t, int, const cuComplex *, const int *,
+ const int *, const cusparseMatDescr_t, int, const cuComplex *,
+ const int *, const int *, const cusparseMatDescr_t, cuComplex *,
+ const int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgemm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrgemm(
+ cusparseHandle_t handle, cusparseOperation_t transA,
+ cusparseOperation_t transB, int m, int n, int k,
+ const cusparseMatDescr_t descrA, int nnzA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const cuDoubleComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ cuDoubleComplex *csrSortedValC, const int *csrSortedRowPtrC,
+ int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, int, int, int,
+ const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
+ const int *, const cusparseMatDescr_t, int, const cuDoubleComplex *,
+ const int *, const int *, const cusparseMatDescr_t, cuDoubleComplex *,
+ const int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgemm");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, transA, transB, m, n, k, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCreateCsrgemm2Info(csrgemm2Info_t *info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrgemm2Info_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsrgemm2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrgemm2Info(csrgemm2Info_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrgemm2Info_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsrgemm2Info");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrgemm2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int k, const float *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB, const float *beta,
+ const cusparseMatDescr_t descrD, int nnzD, const int *csrSortedRowPtrD,
+ const int *csrSortedColIndD, csrgemm2Info_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const cusparseMatDescr_t,
+ int, const int *, const int *, const cusparseMatDescr_t, int, const int *,
+ const int *, const float *, const cusparseMatDescr_t, int, const int *,
+ const int *, csrgemm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgemm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
+ csrSortedColIndD, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrgemm2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int k, const double *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const double *beta, const cusparseMatDescr_t descrD, int nnzD,
+ const int *csrSortedRowPtrD, const int *csrSortedColIndD,
+ csrgemm2Info_t info, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const cusparseMatDescr_t,
+ int, const int *, const int *, const cusparseMatDescr_t, int, const int *,
+ const int *, const double *, const cusparseMatDescr_t, int, const int *,
+ const int *, csrgemm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgemm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
+ csrSortedColIndD, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrgemm2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int k, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cuComplex *beta, const cusparseMatDescr_t descrD, int nnzD,
+ const int *csrSortedRowPtrD, const int *csrSortedColIndD,
+ csrgemm2Info_t info, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, int, const int *, const int *,
+ const cusparseMatDescr_t, int, const int *, const int *,
+ const cuComplex *, const cusparseMatDescr_t, int, const int *,
+ const int *, csrgemm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgemm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
+ csrSortedColIndD, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrgemm2_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int k, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cuDoubleComplex *beta, const cusparseMatDescr_t descrD, int nnzD,
+ const int *csrSortedRowPtrD, const int *csrSortedColIndD,
+ csrgemm2Info_t info, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, int, const int *, const int *,
+ const cusparseMatDescr_t, int, const int *, const int *,
+ const cuDoubleComplex *, const cusparseMatDescr_t, int, const int *,
+ const int *, csrgemm2Info_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgemm2_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
+ csrSortedColIndD, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrgemm2Nnz(
+ cusparseHandle_t handle, int m, int n, int k,
+ const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrD, int nnzD, const int *csrSortedRowPtrD,
+ const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
+ int *csrSortedRowPtrC, int *nnzTotalDevHostPtr, const csrgemm2Info_t info,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, int,
+ const int *, const int *, const cusparseMatDescr_t, int, const int *,
+ const int *, const cusparseMatDescr_t, int, const int *, const int *,
+ const cusparseMatDescr_t, int *, int *, const csrgemm2Info_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrgemm2Nnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, descrD, nnzD, csrSortedRowPtrD,
+ csrSortedColIndD, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrgemm2(
+ cusparseHandle_t handle, int m, int n, int k, const float *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const float *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB, const float *beta,
+ const cusparseMatDescr_t descrD, int nnzD, const float *csrSortedValD,
+ const int *csrSortedRowPtrD, const int *csrSortedColIndD,
+ const cusparseMatDescr_t descrC, float *csrSortedValC,
+ const int *csrSortedRowPtrC, int *csrSortedColIndC,
+ const csrgemm2Info_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const cusparseMatDescr_t,
+ int, const float *, const int *, const int *, const cusparseMatDescr_t,
+ int, const float *, const int *, const int *, const float *,
+ const cusparseMatDescr_t, int, const float *, const int *, const int *,
+ const cusparseMatDescr_t, float *, const int *, int *,
+ const csrgemm2Info_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgemm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
+ descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
+ csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
+ csrSortedColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrgemm2(
+ cusparseHandle_t handle, int m, int n, int k, const double *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const double *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const double *beta, const cusparseMatDescr_t descrD, int nnzD,
+ const double *csrSortedValD, const int *csrSortedRowPtrD,
+ const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
+ double *csrSortedValC, const int *csrSortedRowPtrC, int *csrSortedColIndC,
+ const csrgemm2Info_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const cusparseMatDescr_t,
+ int, const double *, const int *, const int *, const cusparseMatDescr_t,
+ int, const double *, const int *, const int *, const double *,
+ const cusparseMatDescr_t, int, const double *, const int *, const int *,
+ const cusparseMatDescr_t, double *, const int *, int *,
+ const csrgemm2Info_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgemm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
+ descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
+ csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
+ csrSortedColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrgemm2(
+ cusparseHandle_t handle, int m, int n, int k, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const cuComplex *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cuComplex *beta, const cusparseMatDescr_t descrD, int nnzD,
+ const cuComplex *csrSortedValD, const int *csrSortedRowPtrD,
+ const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
+ cuComplex *csrSortedValC, const int *csrSortedRowPtrC,
+ int *csrSortedColIndC, const csrgemm2Info_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *,
+ const cusparseMatDescr_t, int, const cuComplex *, const int *,
+ const int *, const cusparseMatDescr_t, int, const cuComplex *,
+ const int *, const int *, const cuComplex *, const cusparseMatDescr_t,
+ int, const cuComplex *, const int *, const int *,
+ const cusparseMatDescr_t, cuComplex *, const int *, int *,
+ const csrgemm2Info_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgemm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
+ descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
+ csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
+ csrSortedColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrgemm2(
+ cusparseHandle_t handle, int m, int n, int k, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
+ const cuDoubleComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cuDoubleComplex *beta,
+ const cusparseMatDescr_t descrD, int nnzD,
+ const cuDoubleComplex *csrSortedValD, const int *csrSortedRowPtrD,
+ const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
+ cuDoubleComplex *csrSortedValC, const int *csrSortedRowPtrC,
+ int *csrSortedColIndC, const csrgemm2Info_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
+ const int *, const cusparseMatDescr_t, int, const cuDoubleComplex *,
+ const int *, const int *, const cuDoubleComplex *,
+ const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
+ const int *, const cusparseMatDescr_t, cuDoubleComplex *, const int *,
+ int *, const csrgemm2Info_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgemm2");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
+ descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
+ csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
+ csrSortedColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrgeamNnz(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ int nnzA, const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrB, int nnzB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ int *csrSortedRowPtrC, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, int, const int *,
+ const int *, const cusparseMatDescr_t, int, const int *, const int *,
+ const cusparseMatDescr_t, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrgeamNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, nnzA, csrSortedRowPtrA,
+ csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
+ csrSortedColIndB, descrC, csrSortedRowPtrC,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrgeam(
+ cusparseHandle_t handle, int m, int n, const float *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, const float *beta,
+ const cusparseMatDescr_t descrB, int nnzB, const float *csrSortedValB,
+ const int *csrSortedRowPtrB, const int *csrSortedColIndB,
+ const cusparseMatDescr_t descrC, float *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, const cusparseMatDescr_t, int,
+ const float *, const int *, const int *, const float *,
+ const cusparseMatDescr_t, int, const float *, const int *, const int *,
+ const cusparseMatDescr_t, float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgeam");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrgeam(
+ cusparseHandle_t handle, int m, int n, const double *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const double *beta, const cusparseMatDescr_t descrB, int nnzB,
+ const double *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ double *csrSortedValC, int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, const cusparseMatDescr_t, int,
+ const double *, const int *, const int *, const double *,
+ const cusparseMatDescr_t, int, const double *, const int *, const int *,
+ const cusparseMatDescr_t, double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgeam");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrgeam(
+ cusparseHandle_t handle, int m, int n, const cuComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cuComplex *beta, const cusparseMatDescr_t descrB, int nnzB,
+ const cuComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ cuComplex *csrSortedValC, int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuComplex *, const cusparseMatDescr_t,
+ int, const cuComplex *, const int *, const int *, const cuComplex *,
+ const cusparseMatDescr_t, int, const cuComplex *, const int *,
+ const int *, const cusparseMatDescr_t, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgeam");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrgeam(
+ cusparseHandle_t handle, int m, int n, const cuDoubleComplex *alpha,
+ const cusparseMatDescr_t descrA, int nnzA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cuDoubleComplex *beta,
+ const cusparseMatDescr_t descrB, int nnzB,
+ const cuDoubleComplex *csrSortedValB, const int *csrSortedRowPtrB,
+ const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
+ cuDoubleComplex *csrSortedValC, int *csrSortedRowPtrC,
+ int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cuDoubleComplex *,
+ const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
+ const int *, const cuDoubleComplex *, const cusparseMatDescr_t, int,
+ const cuDoubleComplex *, const int *, const int *,
+ const cusparseMatDescr_t, cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgeam");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
+ csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsrcolor(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *fractionToColor, int *ncolors,
+ int *coloring, int *reordering, const cusparseColorInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, const float *, int *, int *, int *,
+ const cusparseColorInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrcolor");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, fractionToColor, ncolors, coloring,
+ reordering, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsrcolor(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const double *fractionToColor, int *ncolors,
+ int *coloring, int *reordering, const cusparseColorInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, int *, int *, int *,
+ const cusparseColorInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrcolor");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, fractionToColor, ncolors, coloring,
+ reordering, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsrcolor(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const float *fractionToColor, int *ncolors,
+ int *coloring, int *reordering, const cusparseColorInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, const float *, int *, int *, int *,
+ const cusparseColorInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrcolor");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, fractionToColor, ncolors, coloring,
+ reordering, info);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsrcolor(
+ cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const double *fractionToColor, int *ncolors,
+ int *coloring, int *reordering, const cusparseColorInfo_t info) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, const double *, int *,
+ int *, int *, const cusparseColorInfo_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrcolor");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, fractionToColor, ncolors, coloring,
+ reordering, info);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseSnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const float *A, int lda,
+ int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, int, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSnnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseDnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const double *A, int lda,
+ int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, int, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuComplex *A, int lda,
+ int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, int, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCnnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *A, int lda,
+ int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, int, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZnnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSnnz_compress(
+ cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
+ const float *csrValA, const int *csrRowPtrA, int *nnzPerRow, int *nnzC,
+ float tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cusparseMatDescr_t, const float *,
+ const int *, int *, int *, float);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSnnz_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, descr, csrValA, csrRowPtrA, nnzPerRow, nnzC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDnnz_compress(
+ cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
+ const double *csrValA, const int *csrRowPtrA, int *nnzPerRow, int *nnzC,
+ double tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cusparseMatDescr_t, const double *,
+ const int *, int *, int *, double);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnnz_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, descr, csrValA, csrRowPtrA, nnzPerRow, nnzC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCnnz_compress(
+ cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
+ const cuComplex *csrValA, const int *csrRowPtrA, int *nnzPerRow, int *nnzC,
+ cuComplex tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, int *, int *, cuComplex);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCnnz_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, descr, csrValA, csrRowPtrA, nnzPerRow, nnzC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZnnz_compress(
+ cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
+ const cuDoubleComplex *csrValA, const int *csrRowPtrA, int *nnzPerRow,
+ int *nnzC, cuDoubleComplex tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, const cusparseMatDescr_t, const cuDoubleComplex *,
+ const int *, int *, int *, cuDoubleComplex);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZnnz_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, descr, csrValA, csrRowPtrA, nnzPerRow, nnzC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2csr_compress(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descra,
+ const float *csrValA, const int *csrColIndA, const int *csrRowPtrA,
+ int nnzA, const int *nnzPerRow, float *csrValC, int *csrColIndC,
+ int *csrRowPtrC, float tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, int, const int *, float *, int *, int *, float);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2csr_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descra, csrValA, csrColIndA, csrRowPtrA, nnzA,
+ nnzPerRow, csrValC, csrColIndC, csrRowPtrC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2csr_compress(
+ cusparseHandle_t handle,
+ int m, // number of rows
+ int n, const cusparseMatDescr_t descra,
+ const double *csrValA, // csr values array-the elements which are below a
+ // certain tolerance will be remvoed
+ const int *csrColIndA,
+ const int *csrRowPtrA, // corresponding input noncompressed row pointer
+ int nnzA, const int *nnzPerRow, double *csrValC, int *csrColIndC,
+ int *csrRowPtrC, double tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, int, const int *, double *, int *, int *,
+ double);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2csr_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descra, csrValA, csrColIndA, csrRowPtrA, nnzA,
+ nnzPerRow, csrValC, csrColIndC, csrRowPtrC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2csr_compress(
+ cusparseHandle_t handle,
+ int m, // number of rows
+ int n, const cusparseMatDescr_t descra,
+ const cuComplex *csrValA, // csr values array-the elements which are below
+ // a certain tolerance will be remvoed
+ const int *csrColIndA,
+ const int *csrRowPtrA, // corresponding input noncompressed row pointer
+ int nnzA, const int *nnzPerRow, cuComplex *csrValC, int *csrColIndC,
+ int *csrRowPtrC, cuComplex tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, int, const int *, cuComplex *, int *, int *,
+ cuComplex);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2csr_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descra, csrValA, csrColIndA, csrRowPtrA, nnzA,
+ nnzPerRow, csrValC, csrColIndC, csrRowPtrC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2csr_compress(
+ cusparseHandle_t handle,
+ int m, // number of rows
+ int n, const cusparseMatDescr_t descra,
+ const cuDoubleComplex *csrValA, // csr values array-the elements which are
+ // below a certain tolerance will be remvoed
+ const int *csrColIndA,
+ const int *csrRowPtrA, // corresponding input noncompressed row pointer
+ int nnzA, const int *nnzPerRow, cuDoubleComplex *csrValC, int *csrColIndC,
+ int *csrRowPtrC, cuDoubleComplex tol) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, const int *,
+ cuDoubleComplex *, int *, int *, cuDoubleComplex);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2csr_compress");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descra, csrValA, csrColIndA, csrRowPtrA, nnzA,
+ nnzPerRow, csrValC, csrColIndC, csrRowPtrC, tol);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSdense2csr(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *A, int lda, const int *nnzPerRow, float *csrSortedValA,
+ int *csrSortedRowPtrA, int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *, int,
+ const int *, float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSdense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDdense2csr(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *A, int lda, const int *nnzPerRow, double *csrSortedValA,
+ int *csrSortedRowPtrA, int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *, int,
+ const int *, double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDdense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCdense2csr(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *A, int lda, const int *nnzPerRow, cuComplex *csrSortedValA,
+ int *csrSortedRowPtrA, int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ int, const int *, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZdense2csr(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *A, int lda, const int *nnzPerRow,
+ cuDoubleComplex *csrSortedValA, int *csrSortedRowPtrA,
+ int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, int, const int *, cuDoubleComplex *, int *,
+ int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
+ csrSortedRowPtrA, csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, float *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, double *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cuComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cuDoubleComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, cuDoubleComplex *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSdense2csc(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *A, int lda, const int *nnzPerCol, float *cscSortedValA,
+ int *cscSortedRowIndA, int *cscSortedColPtrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *, int,
+ const int *, float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSdense2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
+ cscSortedRowIndA, cscSortedColPtrA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDdense2csc(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *A, int lda, const int *nnzPerCol, double *cscSortedValA,
+ int *cscSortedRowIndA, int *cscSortedColPtrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *, int,
+ const int *, double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDdense2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
+ cscSortedRowIndA, cscSortedColPtrA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCdense2csc(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *A, int lda, const int *nnzPerCol, cuComplex *cscSortedValA,
+ int *cscSortedRowIndA, int *cscSortedColPtrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ int, const int *, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdense2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
+ cscSortedRowIndA, cscSortedColPtrA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZdense2csc(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *A, int lda, const int *nnzPerCol,
+ cuDoubleComplex *cscSortedValA, int *cscSortedRowIndA,
+ int *cscSortedColPtrA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, int, const int *, cuDoubleComplex *, int *,
+ int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdense2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
+ cscSortedRowIndA, cscSortedColPtrA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsc2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, float *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsc2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsc2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, double *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsc2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsc2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cuComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsc2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsc2dense(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cuDoubleComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, cuDoubleComplex *,
+ int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsc2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcoo2csr(cusparseHandle_t handle,
+ const int *cooRowInd, int nnz,
+ int m, int *csrSortedRowPtr,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const int *, int, int, int *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoo2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, cooRowInd, nnz, m, csrSortedRowPtr, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsr2coo(cusparseHandle_t handle,
+ const int *csrSortedRowPtr,
+ int nnz, int m, int *cooRowInd,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const int *, int, int, int *, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsr2coo");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, csrSortedRowPtr, nnz, m, cooRowInd, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCsr2cscEx(
+ cusparseHandle_t handle, int m, int n, int nnz, const void *csrSortedVal,
+ cudaDataType csrSortedValtype, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, void *cscSortedVal,
+ cudaDataType cscSortedValtype, int *cscSortedRowInd, int *cscSortedColPtr,
+ cusparseAction_t copyValues, cusparseIndexBase_t idxBase,
+ cudaDataType executiontype) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const void *, cudaDataType, const int *,
+ const int *, void *, cudaDataType, int *, int *, cusparseAction_t,
+ cusparseIndexBase_t, cudaDataType);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsr2cscEx");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrSortedVal, csrSortedValtype,
+ csrSortedRowPtr, csrSortedColInd, cscSortedVal,
+ cscSortedValtype, cscSortedRowInd, cscSortedColPtr,
+ copyValues, idxBase, executiontype);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2csc(
+ cusparseHandle_t handle, int m, int n, int nnz, const float *csrSortedVal,
+ const int *csrSortedRowPtr, const int *csrSortedColInd, float *cscSortedVal,
+ int *cscSortedRowInd, int *cscSortedColPtr, cusparseAction_t copyValues,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const int *, const int *,
+ float *, int *, int *, cusparseAction_t, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr, copyValues, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2csc(
+ cusparseHandle_t handle, int m, int n, int nnz, const double *csrSortedVal,
+ const int *csrSortedRowPtr, const int *csrSortedColInd,
+ double *cscSortedVal, int *cscSortedRowInd, int *cscSortedColPtr,
+ cusparseAction_t copyValues, cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const int *, const int *,
+ double *, int *, int *, cusparseAction_t, cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr, copyValues, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCcsr2csc(cusparseHandle_t handle, int m, int n, int nnz,
+ const cuComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, cuComplex *cscSortedVal,
+ int *cscSortedRowInd, int *cscSortedColPtr,
+ cusparseAction_t copyValues, cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *, const int *,
+ const int *, cuComplex *, int *, int *, cusparseAction_t,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr, copyValues, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2csc(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cuDoubleComplex *csrSortedVal, const int *csrSortedRowPtr,
+ const int *csrSortedColInd, cuDoubleComplex *cscSortedVal,
+ int *cscSortedRowInd, int *cscSortedColPtr, cusparseAction_t copyValues,
+ cusparseIndexBase_t idxBase) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *, const int *,
+ const int *, cuDoubleComplex *, int *, int *, cusparseAction_t,
+ cusparseIndexBase_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrSortedVal, csrSortedRowPtr,
+ csrSortedColInd, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr, copyValues, idxBase);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSdense2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *A, int lda, const int *nnzPerRow, cusparseHybMat_t hybA,
+ int userEllWidth, cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *, int,
+ const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSdense2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth,
+ partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDdense2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *A, int lda, const int *nnzPerRow, cusparseHybMat_t hybA,
+ int userEllWidth, cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *, int,
+ const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDdense2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth,
+ partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCdense2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *A, int lda, const int *nnzPerRow, cusparseHybMat_t hybA,
+ int userEllWidth, cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ int, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdense2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth,
+ partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseZdense2hyb(cusparseHandle_t handle, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *A,
+ int lda, const int *nnzPerRow, cusparseHybMat_t hybA,
+ int userEllWidth, cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, int, const int *, cusparseHybMat_t, int,
+ cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdense2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth,
+ partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseShyb2dense(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ float *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ float *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShyb2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDhyb2dense(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ double *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ double *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhyb2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseChyb2dense(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChyb2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZhyb2dense(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuDoubleComplex *A, int lda) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuDoubleComplex *, int);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhyb2dense");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, A, lda);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, cusparseHybMat_t, int,
+ cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseShyb2csr(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ float *csrSortedValA,
+ int *csrSortedRowPtrA,
+ int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShyb2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDhyb2csr(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ double *csrSortedValA,
+ int *csrSortedRowPtrA,
+ int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhyb2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseChyb2csr(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuComplex *csrSortedValA,
+ int *csrSortedRowPtrA,
+ int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChyb2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZhyb2csr(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuDoubleComplex *csrSortedValA,
+ int *csrSortedRowPtrA,
+ int *csrSortedColIndA) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhyb2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsc2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const float *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsc2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsc2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const double *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsc2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsc2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuComplex *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
+ const int *, const int *, cusparseHybMat_t, int, cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsc2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsc2hyb(
+ cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
+ const cuDoubleComplex *cscSortedValA, const int *cscSortedRowIndA,
+ const int *cscSortedColPtrA, cusparseHybMat_t hybA, int userEllWidth,
+ cusparseHybPartition_t partitionType) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, cusparseHybMat_t, int,
+ cusparseHybPartition_t);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsc2hyb");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
+ cscSortedColPtrA, hybA, userEllWidth, partitionType);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseShyb2csc(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ float *cscSortedVal,
+ int *cscSortedRowInd,
+ int *cscSortedColPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseShyb2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDhyb2csc(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ double *cscSortedVal,
+ int *cscSortedRowInd,
+ int *cscSortedColPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDhyb2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseChyb2csc(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuComplex *cscSortedVal,
+ int *cscSortedRowInd,
+ int *cscSortedColPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseChyb2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZhyb2csc(cusparseHandle_t handle,
+ const cusparseMatDescr_t descrA,
+ const cusparseHybMat_t hybA,
+ cuDoubleComplex *cscSortedVal,
+ int *cscSortedRowInd,
+ int *cscSortedColPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, const cusparseMatDescr_t, const cusparseHybMat_t,
+ cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZhyb2csc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, descrA, hybA, cscSortedVal, cscSortedRowInd,
+ cscSortedColPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsr2bsrNnz(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, int blockDim, const cusparseMatDescr_t descrC,
+ int *bsrSortedRowPtrC, int *nnzTotalDevHostPtr) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const int *, const int *, int, const cusparseMatDescr_t, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsr2bsrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedRowPtrA,
+ csrSortedColIndA, blockDim, descrC, bsrSortedRowPtrC,
+ nnzTotalDevHostPtr);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2bsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, float *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, const cusparseMatDescr_t,
+ float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2bsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, blockDim, descrC, bsrSortedValC,
+ bsrSortedRowPtrC, bsrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2bsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, double *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, const cusparseMatDescr_t,
+ double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2bsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, blockDim, descrC, bsrSortedValC,
+ bsrSortedRowPtrC, bsrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2bsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, cuComplex *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int,
+ const cusparseMatDescr_t, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2bsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, blockDim, descrC, bsrSortedValC,
+ bsrSortedRowPtrC, bsrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2bsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, cuDoubleComplex *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int,
+ const cusparseMatDescr_t, cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2bsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, blockDim, descrC, bsrSortedValC,
+ bsrSortedRowPtrC, bsrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSbsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, float *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, const cusparseMatDescr_t,
+ float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, blockDim, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDbsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, double *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, const cusparseMatDescr_t,
+ double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, blockDim, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCbsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, cuComplex *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int,
+ const cusparseMatDescr_t, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, blockDim, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZbsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
+ const cusparseMatDescr_t descrC, cuDoubleComplex *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int,
+ const cusparseMatDescr_t, cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, blockDim, descrC, csrSortedValC,
+ csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc_bufferSize(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const float *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const int *, const int *,
+ int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsc_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc_bufferSize(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const double *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const int *, const int *,
+ int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsc_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc_bufferSize(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *, const int *,
+ const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsc_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc_bufferSize(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *, const int *,
+ const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsc_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc_bufferSizeExt(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const float *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const int *, const int *,
+ int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSgebsr2gebsc_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc_bufferSizeExt(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const double *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const int *, const int *,
+ int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDgebsr2gebsc_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc_bufferSizeExt(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *, const int *,
+ const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCgebsr2gebsc_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc_bufferSizeExt(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *, const int *,
+ const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZgebsr2gebsc_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const float *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim, float *bscVal,
+ int *bscRowInd, int *bscColPtr, cusparseAction_t copyValues,
+ cusparseIndexBase_t baseIdx, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const float *, const int *, const int *,
+ int, int, float *, int *, int *, cusparseAction_t, cusparseIndexBase_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
+ bscColPtr, copyValues, baseIdx, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const double *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ double *bscVal, int *bscRowInd, int *bscColPtr, cusparseAction_t copyValues,
+ cusparseIndexBase_t baseIdx, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const double *, const int *, const int *,
+ int, int, double *, int *, int *, cusparseAction_t, cusparseIndexBase_t,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
+ bscColPtr, copyValues, baseIdx, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ cuComplex *bscVal, int *bscRowInd, int *bscColPtr,
+ cusparseAction_t copyValues, cusparseIndexBase_t baseIdx, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuComplex *, const int *,
+ const int *, int, int, cuComplex *, int *, int *, cusparseAction_t,
+ cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
+ bscColPtr, copyValues, baseIdx, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc(
+ cusparseHandle_t handle, int mb, int nb, int nnzb,
+ const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
+ const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
+ cuDoubleComplex *bscVal, int *bscRowInd, int *bscColPtr,
+ cusparseAction_t copyValues, cusparseIndexBase_t baseIdx, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cuDoubleComplex *, const int *,
+ const int *, int, int, cuDoubleComplex *, int *, int *, cusparseAction_t,
+ cusparseIndexBase_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsc");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
+ bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
+ bscColPtr, copyValues, baseIdx, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXgebsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, int rowBlockDim, int colBlockDim,
+ const cusparseMatDescr_t descrC, int *csrSortedRowPtrC,
+ int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const int *, const int *, int, int, const cusparseMatDescr_t, int *,
+ int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXgebsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
+ csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
+ int colBlockDim, const cusparseMatDescr_t descrC, float *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, int,
+ const cusparseMatDescr_t, float *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
+ int colBlockDim, const cusparseMatDescr_t descrC, double *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, int,
+ const cusparseMatDescr_t, double *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
+ int colBlockDim, const cusparseMatDescr_t descrC, cuComplex *csrSortedValC,
+ int *csrSortedRowPtrC, int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int, int,
+ const cusparseMatDescr_t, cuComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2csr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
+ int colBlockDim, const cusparseMatDescr_t descrC,
+ cuDoubleComplex *csrSortedValC, int *csrSortedRowPtrC,
+ int *csrSortedColIndC) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, int,
+ const cusparseMatDescr_t, cuDoubleComplex *, int *, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
+ csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseScsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDcsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCcsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
+ int colBlockDim, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZcsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsr2gebsrNnz(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const int *csrSortedRowPtrA,
+ const int *csrSortedColIndA, const cusparseMatDescr_t descrC,
+ int *bsrSortedRowPtrC, int rowBlockDim, int colBlockDim,
+ int *nnzTotalDevHostPtr, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const int *, const int *, const cusparseMatDescr_t, int *, int, int,
+ int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsr2gebsrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedRowPtrA,
+ csrSortedColIndA, descrC, bsrSortedRowPtrC, rowBlockDim,
+ colBlockDim, nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const float *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrC, float *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
+ int colBlockDim, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const float *, const int *, const int *, const cusparseMatDescr_t,
+ float *, int *, int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const double *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrC, double *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
+ int colBlockDim, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const double *, const int *, const int *, const cusparseMatDescr_t,
+ double *, int *, int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrC, cuComplex *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
+ int colBlockDim, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuComplex *, const int *, const int *, const cusparseMatDescr_t,
+ cuComplex *, int *, int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
+ const int *csrSortedRowPtrA, const int *csrSortedColIndA,
+ const cusparseMatDescr_t descrC, cuDoubleComplex *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
+ int colBlockDim, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
+ const cuDoubleComplex *, const int *, const int *,
+ const cusparseMatDescr_t, cuDoubleComplex *, int *, int *, int, int,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
+ csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const float *, const int *, const int *, int,
+ int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const double *, const int *, const int *, int,
+ int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ int, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr_bufferSize(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC,
+ int *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, int, int, int, int, int *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsr_bufferSize");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const float *, const int *, const int *, int,
+ int, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSgebsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const double *, const int *, const int *, int,
+ int, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDgebsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ int, int, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCgebsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr_bufferSizeExt(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, int, int, int, int, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseZgebsr2gebsr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXgebsr2gebsrNnz(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const int *bsrSortedRowPtrA,
+ const int *bsrSortedColIndA, int rowBlockDimA, int colBlockDimA,
+ const cusparseMatDescr_t descrC, int *bsrSortedRowPtrC, int rowBlockDimC,
+ int colBlockDimC, int *nnzTotalDevHostPtr, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const int *, const int *, int, int,
+ const cusparseMatDescr_t, int *, int, int, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXgebsr2gebsrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedRowPtrA,
+ bsrSortedColIndA, rowBlockDimA, colBlockDimA, descrC,
+ bsrSortedRowPtrC, rowBlockDimC, colBlockDimC,
+ nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const float *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, const cusparseMatDescr_t descrC, float *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDimC,
+ int colBlockDimC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const float *, const int *, const int *, int,
+ int, const cusparseMatDescr_t, float *, int *, int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const double *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, const cusparseMatDescr_t descrC, double *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDimC,
+ int colBlockDimC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const double *, const int *, const int *, int,
+ int, const cusparseMatDescr_t, double *, int *, int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, const cusparseMatDescr_t descrC, cuComplex *bsrSortedValC,
+ int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDimC,
+ int colBlockDimC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
+ int, int, const cusparseMatDescr_t, cuComplex *, int *, int *, int, int,
+ void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr(
+ cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
+ const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
+ const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
+ int colBlockDimA, const cusparseMatDescr_t descrC,
+ cuDoubleComplex *bsrSortedValC, int *bsrSortedRowPtrC,
+ int *bsrSortedColIndC, int rowBlockDimC, int colBlockDimC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, cusparseDirection_t, int, int, int,
+ const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
+ const int *, int, int, const cusparseMatDescr_t, cuDoubleComplex *, int *,
+ int *, int, int, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
+ bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
+ colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
+ bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI
+cusparseCreateIdentityPermutation(cusparseHandle_t handle, int n, int *p) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, int *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseCreateIdentityPermutation");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, n, p);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcoosort_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, const int *cooRowsA,
+ const int *cooColsA, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const int *, const int *, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoosort_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, cooRowsA, cooColsA, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcoosortByRow(cusparseHandle_t handle,
+ int m, int n, int nnz,
+ int *cooRowsA, int *cooColsA,
+ int *P, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int *, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoosortByRow");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, cooRowsA, cooColsA, P, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcoosortByColumn(cusparseHandle_t handle,
+ int m, int n, int nnz,
+ int *cooRowsA,
+ int *cooColsA, int *P,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, int *, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoosortByColumn");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, cooRowsA, cooColsA, P, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrsort_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, const int *csrRowPtrA,
+ const int *csrColIndA, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const int *, const int *, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrsort_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrRowPtrA, csrColIndA,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcsrsort(cusparseHandle_t handle, int m,
+ int n, int nnz,
+ const cusparseMatDescr_t descrA,
+ const int *csrRowPtrA,
+ int *csrColIndA, int *P,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const int *,
+ int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrsort");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrRowPtrA, csrColIndA, P,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcscsort_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, const int *cscColPtrA,
+ const int *cscRowIndA, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const int *, const int *, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcscsort_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, cscColPtrA, cscRowIndA,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseXcscsort(cusparseHandle_t handle, int m,
+ int n, int nnz,
+ const cusparseMatDescr_t descrA,
+ const int *cscColPtrA,
+ int *cscRowIndA, int *P,
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const int *,
+ int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcscsort");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, cscColPtrA, cscRowIndA, P,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsru2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, float *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, float *, const int *, int *,
+ csru2csrInfo_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsru2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsru2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, double *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, double *, const int *, int *,
+ csru2csrInfo_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsru2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsru2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, cuComplex *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, cuComplex *, const int *, int *,
+ csru2csrInfo_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsru2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsru2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnz, cuDoubleComplex *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, cuDoubleComplex *, const int *, int *,
+ csru2csrInfo_t, size_t *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsru2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsru2csr(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, float *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, float *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsru2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsru2csr(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, double *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, double *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsru2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsru2csr(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, cuComplex *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsru2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsru2csr(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsru2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseScsr2csru(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, float *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, float *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2csru");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDcsr2csru(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, double *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, double *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2csru");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseCcsr2csru(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, cuComplex *csrVal, const int *csrRowPtr,
+ int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
+ const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2csru");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseZcsr2csru(
+ cusparseHandle_t handle, int m, int n, int nnz,
+ const cusparseMatDescr_t descrA, cuDoubleComplex *csrVal,
+ const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t,
+ cuDoubleComplex *, const int *, int *, csru2csrInfo_t, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2csru");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ const float *threshold, const cusparseMatDescr_t descrC,
+ const float *csrValC, const int *csrRowPtrC, const int *csrColIndC,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, const float *,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneDense2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrValC, csrRowPtrC,
+ csrColIndC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ const double *threshold, const cusparseMatDescr_t descrC,
+ const double *csrValC, const int *csrRowPtrC, const int *csrColIndC,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, const double *,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneDense2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrValC, csrRowPtrC,
+ csrColIndC, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrNnz(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ const float *threshold, const cusparseMatDescr_t descrC, int *csrRowPtrC,
+ int *nnzTotalDevHostPtr, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, const float *,
+ const cusparseMatDescr_t, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneDense2csrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrRowPtrC,
+ nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrNnz(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ const double *threshold, const cusparseMatDescr_t descrC, int *csrRowPtrC,
+ int *nnzTotalDevHostPtr, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, const double *,
+ const cusparseMatDescr_t, int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneDense2csrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrRowPtrC,
+ nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csr(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ const float *threshold, const cusparseMatDescr_t descrC, float *csrValC,
+ const int *csrRowPtrC, int *csrColIndC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, const float *,
+ const cusparseMatDescr_t, float *, const int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneDense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrValC, csrRowPtrC,
+ csrColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csr(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ const double *threshold, const cusparseMatDescr_t descrC, double *csrValC,
+ const int *csrRowPtrC, int *csrColIndC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, const double *,
+ const cusparseMatDescr_t, double *, const int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneDense2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, threshold, descrC, csrValC, csrRowPtrC,
+ csrColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA, const float *threshold,
+ const cusparseMatDescr_t descrC, const float *csrValC,
+ const int *csrRowPtrC, const int *csrColIndC, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, const float *, const cusparseMatDescr_t,
+ const float *, const int *, const int *, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneCsr2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ threshold, descrC, csrValC, csrRowPtrC, csrColIndC,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csr_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA, const double *threshold,
+ const cusparseMatDescr_t descrC, const double *csrValC,
+ const int *csrRowPtrC, const int *csrColIndC, size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, const cusparseMatDescr_t,
+ const double *, const int *, const int *, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneCsr2csr_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ threshold, descrC, csrValC, csrRowPtrC, csrColIndC,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrNnz(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA, const float *threshold,
+ const cusparseMatDescr_t descrC, int *csrRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, const float *, const cusparseMatDescr_t, int *,
+ int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ threshold, descrC, csrRowPtrC, nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrNnz(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA, const double *threshold,
+ const cusparseMatDescr_t descrC, int *csrRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, const cusparseMatDescr_t, int *,
+ int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrNnz");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ threshold, descrC, csrRowPtrC, nnzTotalDevHostPtr, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csr(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA, const float *threshold,
+ const cusparseMatDescr_t descrC, float *csrValC, const int *csrRowPtrC,
+ int *csrColIndC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, const float *, const cusparseMatDescr_t,
+ float *, const int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneCsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ threshold, descrC, csrValC, csrRowPtrC, csrColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csr(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA, const double *threshold,
+ const cusparseMatDescr_t descrC, double *csrValC, const int *csrRowPtrC,
+ int *csrColIndC, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, const double *, const cusparseMatDescr_t,
+ double *, const int *, int *, void *);
+ static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneCsr2csr");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ threshold, descrC, csrValC, csrRowPtrC, csrColIndC, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrByPercentage_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, const float *csrValC,
+ const int *csrRowPtrC, const int *csrColIndC, pruneInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, float,
+ const cusparseMatDescr_t, const float *, const int *, const int *,
+ pruneInfo_t, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneDense2csrByPercentage_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrValC, csrRowPtrC,
+ csrColIndC, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrByPercentage_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, const double *csrValC,
+ const int *csrRowPtrC, const int *csrColIndC, pruneInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, float,
+ const cusparseMatDescr_t, const double *, const int *, const int *,
+ pruneInfo_t, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneDense2csrByPercentage_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrValC, csrRowPtrC,
+ csrColIndC, info, pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrNnzByPercentage(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, int *csrRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, float,
+ const cusparseMatDescr_t, int *, int *, pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneDense2csrNnzByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrRowPtrC,
+ nnzTotalDevHostPtr, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrNnzByPercentage(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, int *csrRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, float,
+ const cusparseMatDescr_t, int *, int *, pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneDense2csrNnzByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrRowPtrC,
+ nnzTotalDevHostPtr, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrByPercentage(
+ cusparseHandle_t handle, int m, int n, const float *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, float *csrValC, const int *csrRowPtrC,
+ int *csrColIndC, pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const float *, int, float,
+ const cusparseMatDescr_t, float *, const int *, int *, pruneInfo_t,
+ void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneDense2csrByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrValC, csrRowPtrC,
+ csrColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrByPercentage(
+ cusparseHandle_t handle, int m, int n, const double *A, int lda,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, double *csrValC, const int *csrRowPtrC,
+ int *csrColIndC, pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, const double *, int, float,
+ const cusparseMatDescr_t, double *, const int *, int *, pruneInfo_t,
+ void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneDense2csrByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, A, lda, percentage, descrC, csrValC, csrRowPtrC,
+ csrColIndC, info, pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrByPercentage_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, const float *csrValC,
+ const int *csrRowPtrC, const int *csrColIndC, pruneInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, float, const cusparseMatDescr_t, const float *,
+ const int *, const int *, pruneInfo_t, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrByPercentage_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ percentage, descrC, csrValC, csrRowPtrC, csrColIndC, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrByPercentage_bufferSizeExt(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, const double *csrValC,
+ const int *csrRowPtrC, const int *csrColIndC, pruneInfo_t info,
+ size_t *pBufferSizeInBytes) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, float, const cusparseMatDescr_t, const double *,
+ const int *, const int *, pruneInfo_t, size_t *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrByPercentage_bufferSizeExt");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ percentage, descrC, csrValC, csrRowPtrC, csrColIndC, info,
+ pBufferSizeInBytes);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrNnzByPercentage(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, int *csrRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, float, const cusparseMatDescr_t, int *, int *,
+ pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrNnzByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ percentage, descrC, csrRowPtrC, nnzTotalDevHostPtr, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrNnzByPercentage(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, int *csrRowPtrC,
+ int *nnzTotalDevHostPtr, /* can be on host or device */
+ pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, float, const cusparseMatDescr_t, int *, int *,
+ pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrNnzByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ percentage, descrC, csrRowPtrC, nnzTotalDevHostPtr, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrByPercentage(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const float *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, float *csrValC, const int *csrRowPtrC,
+ int *csrColIndC, pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
+ const int *, const int *, float, const cusparseMatDescr_t, float *,
+ const int *, int *, pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ percentage, descrC, csrValC, csrRowPtrC, csrColIndC, info,
+ pBuffer);
+}
+
+cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrByPercentage(
+ cusparseHandle_t handle, int m, int n, int nnzA,
+ const cusparseMatDescr_t descrA, const double *csrValA,
+ const int *csrRowPtrA, const int *csrColIndA,
+ float percentage, /* between 0 to 100 */
+ const cusparseMatDescr_t descrC, double *csrValC, const int *csrRowPtrC,
+ int *csrColIndC, pruneInfo_t info, void *pBuffer) {
+ using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
+ cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
+ const int *, const int *, float, const cusparseMatDescr_t, double *,
+ const int *, int *, pruneInfo_t, void *);
+ static auto func_ptr =
+ LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrByPercentage");
+ if (!func_ptr) return GetSymbolNotFoundError();
+ return func_ptr(handle, m, n, nnzA, descrA, csrValA, csrRowPtrA, csrColIndA,
+ percentage, descrC, csrValC, csrRowPtrC, csrColIndC, info,
+ pBuffer);
+}
+
+} // extern "C"
diff --git a/tensorflow/stream_executor/cuda/cusparse_stub.cc b/tensorflow/stream_executor/cuda/cusparse_stub.cc
new file mode 100644
index 00000000000..20ea7a7a85c
--- /dev/null
+++ b/tensorflow/stream_executor/cuda/cusparse_stub.cc
@@ -0,0 +1,57 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#include "cuda/include/cusparse.h"
+#include "tensorflow/stream_executor/lib/env.h"
+#include "tensorflow/stream_executor/platform/dso_loader.h"
+
+// Implements the cusparse API by forwarding to cusparse loaded from the DSO.
+
+namespace {
+// Returns DSO handle or null if loading the DSO fails.
+void* GetDsoHandle() {
+#ifdef PLATFORM_GOOGLE
+ return nullptr;
+#else
+ static auto handle = []() -> void* {
+ auto handle_or =
+ stream_executor::internal::DsoLoader::GetCusparseDsoHandle();
+ if (!handle_or.ok()) return nullptr;
+ return handle_or.ValueOrDie();
+ }();
+ return handle;
+#endif
+}
+
+template <typename T>
+T LoadSymbol(const char* symbol_name) {
+ void* symbol = nullptr;
+ if (auto handle = GetDsoHandle()) {
+ stream_executor::port::Env::Default()
+ ->GetSymbolFromLibrary(handle, symbol_name, &symbol)
+ .IgnoreError();
+ }
+ return reinterpret_cast<T>(symbol);
+}
+
+cusparseStatus_t GetSymbolNotFoundError() {
+ return CUSPARSE_STATUS_INTERNAL_ERROR;
+}
+} // namespace
+
+#if CUDA_VERSION < 9020
+#include "tensorflow/stream_executor/cuda/cusparse_9_0.inc"
+#else
+#include "tensorflow/stream_executor/cuda/cusparse_10_0.inc"
+#endif
diff --git a/tensorflow/stream_executor/platform/default/dso_loader.cc b/tensorflow/stream_executor/platform/default/dso_loader.cc
index ede91144ade..d4ba67fd7de 100644
--- a/tensorflow/stream_executor/platform/default/dso_loader.cc
+++ b/tensorflow/stream_executor/platform/default/dso_loader.cc
@@ -83,6 +83,14 @@ port::StatusOr<void*> GetCufftDsoHandle() {
return GetDsoHandle("cufft", GetCudaLibVersion());
}
+port::StatusOr<void*> GetCusolverDsoHandle() {
+ return GetDsoHandle("cusolver", GetCudaVersion());
+}
+
+port::StatusOr<void*> GetCusparseDsoHandle() {
+ return GetDsoHandle("cusparse", GetCudaVersion());
+}
+
port::StatusOr<void*> GetCurandDsoHandle() {
return GetDsoHandle("curand", GetCudaLibVersion());
}
@@ -147,6 +155,16 @@ port::StatusOr<void*> GetCufftDsoHandle() {
return *result;
}
+port::StatusOr<void*> GetCusolverDsoHandle() {
+ static auto result = new auto(DsoLoader::GetCusolverDsoHandle());
+ return *result;
+}
+
+port::StatusOr<void*> GetCusparseDsoHandle() {
+ static auto result = new auto(DsoLoader::GetCusparseDsoHandle());
+ return *result;
+}
+
port::StatusOr<void*> GetCuptiDsoHandle() {
static auto result = new auto(DsoLoader::GetCuptiDsoHandle());
return *result;
diff --git a/tensorflow/stream_executor/platform/default/dso_loader.h b/tensorflow/stream_executor/platform/default/dso_loader.h
index 89f23324dcd..4c868226ae5 100644
--- a/tensorflow/stream_executor/platform/default/dso_loader.h
+++ b/tensorflow/stream_executor/platform/default/dso_loader.h
@@ -39,6 +39,8 @@ port::StatusOr<void*> GetCudaRuntimeDsoHandle();
port::StatusOr<void*> GetCublasDsoHandle();
port::StatusOr<void*> GetCufftDsoHandle();
port::StatusOr<void*> GetCurandDsoHandle();
+port::StatusOr<void*> GetCusolverDsoHandle();
+port::StatusOr<void*> GetCusparseDsoHandle();
port::StatusOr<void*> GetCuptiDsoHandle();
port::StatusOr<void*> GetCudnnDsoHandle();
@@ -58,6 +60,8 @@ port::StatusOr<void*> GetCudaRuntimeDsoHandle();
port::StatusOr<void*> GetCublasDsoHandle();
port::StatusOr<void*> GetCufftDsoHandle();
port::StatusOr<void*> GetCurandDsoHandle();
+port::StatusOr<void*> GetCusolverDsoHandle();
+port::StatusOr<void*> GetCusparseDsoHandle();
port::StatusOr<void*> GetCuptiDsoHandle();
port::StatusOr<void*> GetCudnnDsoHandle();