1// Auto-generated, do not edit. 2 3extern "C" { 4 5cublasStatus_t CUBLASWINAPI cublasCreate_v2(cublasHandle_t *handle) { 6 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t *); 7 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCreate_v2"); 8 if (!func_ptr) return GetSymbolNotFoundError(); 9 return func_ptr(handle); 10} 11 12cublasStatus_t CUBLASWINAPI cublasDestroy_v2(cublasHandle_t handle) { 13 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t); 14 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDestroy_v2"); 15 if (!func_ptr) return GetSymbolNotFoundError(); 16 return func_ptr(handle); 17} 18 19cublasStatus_t CUBLASWINAPI cublasGetVersion_v2(cublasHandle_t handle, 20 int *version) { 21 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int *); 22 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetVersion_v2"); 23 if (!func_ptr) return GetSymbolNotFoundError(); 24 return func_ptr(handle, version); 25} 26 27cublasStatus_t CUBLASWINAPI cublasGetProperty(libraryPropertyType type, 28 int *value) { 29 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(libraryPropertyType, int *); 30 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetProperty"); 31 if (!func_ptr) return GetSymbolNotFoundError(); 32 return func_ptr(type, value); 33} 34 35size_t CUBLASWINAPI cublasGetCudartVersion(void) { 36 using FuncPtr = size_t(CUBLASWINAPI *)(); 37 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetCudartVersion"); 38 if (!func_ptr) LogFatalSymbolNotFound("cublasGetCudartVersion"); 39 return func_ptr(); 40} 41 42cublasStatus_t CUBLASWINAPI cublasSetWorkspace_v2(cublasHandle_t handle, 43 void *workspace, 44 size_t workspaceSizeInBytes) { 45 using FuncPtr = 46 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, void *, size_t); 47 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetWorkspace_v2"); 48 if (!func_ptr) return GetSymbolNotFoundError(); 49 return func_ptr(handle, workspace, workspaceSizeInBytes); 50} 51 52cublasStatus_t CUBLASWINAPI cublasSetStream_v2(cublasHandle_t handle, 53 cudaStream_t streamId) { 54 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cudaStream_t); 55 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetStream_v2"); 56 if (!func_ptr) return GetSymbolNotFoundError(); 57 return func_ptr(handle, streamId); 58} 59 60cublasStatus_t CUBLASWINAPI cublasGetStream_v2(cublasHandle_t handle, 61 cudaStream_t *streamId) { 62 using FuncPtr = 63 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cudaStream_t *); 64 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetStream_v2"); 65 if (!func_ptr) return GetSymbolNotFoundError(); 66 return func_ptr(handle, streamId); 67} 68 69cublasStatus_t CUBLASWINAPI cublasGetPointerMode_v2(cublasHandle_t handle, 70 cublasPointerMode_t *mode) { 71 using FuncPtr = 72 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasPointerMode_t *); 73 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetPointerMode_v2"); 74 if (!func_ptr) return GetSymbolNotFoundError(); 75 return func_ptr(handle, mode); 76} 77 78cublasStatus_t CUBLASWINAPI cublasSetPointerMode_v2(cublasHandle_t handle, 79 cublasPointerMode_t mode) { 80 using FuncPtr = 81 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasPointerMode_t); 82 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetPointerMode_v2"); 83 if (!func_ptr) return GetSymbolNotFoundError(); 84 return func_ptr(handle, mode); 85} 86 87cublasStatus_t CUBLASWINAPI cublasGetAtomicsMode(cublasHandle_t handle, 88 cublasAtomicsMode_t *mode) { 89 using FuncPtr = 90 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasAtomicsMode_t *); 91 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetAtomicsMode"); 92 if (!func_ptr) return GetSymbolNotFoundError(); 93 return func_ptr(handle, mode); 94} 95 96cublasStatus_t CUBLASWINAPI cublasSetAtomicsMode(cublasHandle_t handle, 97 cublasAtomicsMode_t mode) { 98 using FuncPtr = 99 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasAtomicsMode_t); 100 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetAtomicsMode"); 101 if (!func_ptr) return GetSymbolNotFoundError(); 102 return func_ptr(handle, mode); 103} 104 105cublasStatus_t CUBLASWINAPI cublasGetMathMode(cublasHandle_t handle, 106 cublasMath_t *mode) { 107 using FuncPtr = 108 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasMath_t *); 109 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetMathMode"); 110 if (!func_ptr) return GetSymbolNotFoundError(); 111 return func_ptr(handle, mode); 112} 113 114cublasStatus_t CUBLASWINAPI cublasSetMathMode(cublasHandle_t handle, 115 cublasMath_t mode) { 116 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasMath_t); 117 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetMathMode"); 118 if (!func_ptr) return GetSymbolNotFoundError(); 119 return func_ptr(handle, mode); 120} 121 122cublasStatus_t CUBLASWINAPI cublasLoggerConfigure(int logIsOn, int logToStdOut, 123 int logToStdErr, 124 const char *logFileName) { 125 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, int, const char *); 126 static auto func_ptr = LoadSymbol<FuncPtr>("cublasLoggerConfigure"); 127 if (!func_ptr) return GetSymbolNotFoundError(); 128 return func_ptr(logIsOn, logToStdOut, logToStdErr, logFileName); 129} 130 131cublasStatus_t CUBLASWINAPI 132cublasSetLoggerCallback(cublasLogCallback userCallback) { 133 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasLogCallback); 134 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetLoggerCallback"); 135 if (!func_ptr) return GetSymbolNotFoundError(); 136 return func_ptr(userCallback); 137} 138 139cublasStatus_t CUBLASWINAPI 140cublasGetLoggerCallback(cublasLogCallback *userCallback) { 141 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasLogCallback *); 142 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetLoggerCallback"); 143 if (!func_ptr) return GetSymbolNotFoundError(); 144 return func_ptr(userCallback); 145} 146 147cublasStatus_t CUBLASWINAPI cublasSetVector(int n, int elemSize, const void *x, 148 int incx, void *devicePtr, 149 int incy) { 150 using FuncPtr = 151 cublasStatus_t(CUBLASWINAPI *)(int, int, const void *, int, void *, int); 152 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetVector"); 153 if (!func_ptr) return GetSymbolNotFoundError(); 154 return func_ptr(n, elemSize, x, incx, devicePtr, incy); 155} 156 157cublasStatus_t CUBLASWINAPI cublasGetVector(int n, int elemSize, const void *x, 158 int incx, void *y, int incy) { 159 using FuncPtr = 160 cublasStatus_t(CUBLASWINAPI *)(int, int, const void *, int, void *, int); 161 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetVector"); 162 if (!func_ptr) return GetSymbolNotFoundError(); 163 return func_ptr(n, elemSize, x, incx, y, incy); 164} 165 166cublasStatus_t CUBLASWINAPI cublasSetMatrix(int rows, int cols, int elemSize, 167 const void *A, int lda, void *B, 168 int ldb) { 169 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, int, const void *, 170 int, void *, int); 171 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetMatrix"); 172 if (!func_ptr) return GetSymbolNotFoundError(); 173 return func_ptr(rows, cols, elemSize, A, lda, B, ldb); 174} 175 176cublasStatus_t CUBLASWINAPI cublasGetMatrix(int rows, int cols, int elemSize, 177 const void *A, int lda, void *B, 178 int ldb) { 179 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, int, const void *, 180 int, void *, int); 181 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetMatrix"); 182 if (!func_ptr) return GetSymbolNotFoundError(); 183 return func_ptr(rows, cols, elemSize, A, lda, B, ldb); 184} 185 186cublasStatus_t CUBLASWINAPI cublasSetVectorAsync(int n, int elemSize, 187 const void *hostPtr, int incx, 188 void *devicePtr, int incy, 189 cudaStream_t stream) { 190 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, const void *, int, 191 void *, int, cudaStream_t); 192 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetVectorAsync"); 193 if (!func_ptr) return GetSymbolNotFoundError(); 194 return func_ptr(n, elemSize, hostPtr, incx, devicePtr, incy, stream); 195} 196 197cublasStatus_t CUBLASWINAPI cublasGetVectorAsync(int n, int elemSize, 198 const void *devicePtr, 199 int incx, void *hostPtr, 200 int incy, 201 cudaStream_t stream) { 202 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, const void *, int, 203 void *, int, cudaStream_t); 204 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetVectorAsync"); 205 if (!func_ptr) return GetSymbolNotFoundError(); 206 return func_ptr(n, elemSize, devicePtr, incx, hostPtr, incy, stream); 207} 208 209cublasStatus_t CUBLASWINAPI cublasSetMatrixAsync(int rows, int cols, 210 int elemSize, const void *A, 211 int lda, void *B, int ldb, 212 cudaStream_t stream) { 213 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 214 int, int, int, const void *, int, void *, int, cudaStream_t); 215 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetMatrixAsync"); 216 if (!func_ptr) return GetSymbolNotFoundError(); 217 return func_ptr(rows, cols, elemSize, A, lda, B, ldb, stream); 218} 219 220cublasStatus_t CUBLASWINAPI cublasGetMatrixAsync(int rows, int cols, 221 int elemSize, const void *A, 222 int lda, void *B, int ldb, 223 cudaStream_t stream) { 224 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 225 int, int, int, const void *, int, void *, int, cudaStream_t); 226 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetMatrixAsync"); 227 if (!func_ptr) return GetSymbolNotFoundError(); 228 return func_ptr(rows, cols, elemSize, A, lda, B, ldb, stream); 229} 230 231void CUBLASWINAPI cublasXerbla(const char *srName, int info) { 232 using FuncPtr = void(CUBLASWINAPI *)(const char *, int); 233 static auto func_ptr = LoadSymbol<FuncPtr>("cublasXerbla"); 234 if (!func_ptr) LogFatalSymbolNotFound("cublasXerbla"); 235 return func_ptr(srName, info); 236} 237 238cublasStatus_t CUBLASWINAPI cublasNrm2Ex(cublasHandle_t handle, int n, 239 const void *x, cudaDataType xType, 240 int incx, void *result, 241 cudaDataType resultType, 242 cudaDataType executionType) { 243 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 244 cublasHandle_t, int, const void *, cudaDataType, int, void *, 245 cudaDataType, cudaDataType); 246 static auto func_ptr = LoadSymbol<FuncPtr>("cublasNrm2Ex"); 247 if (!func_ptr) return GetSymbolNotFoundError(); 248 return func_ptr(handle, n, x, xType, incx, result, resultType, executionType); 249} 250 251cublasStatus_t CUBLASWINAPI cublasSnrm2_v2(cublasHandle_t handle, int n, 252 const float *x, int incx, 253 float *result) { 254 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 255 const float *, int, float *); 256 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSnrm2_v2"); 257 if (!func_ptr) return GetSymbolNotFoundError(); 258 return func_ptr(handle, n, x, incx, result); 259} 260 261cublasStatus_t CUBLASWINAPI cublasDnrm2_v2(cublasHandle_t handle, int n, 262 const double *x, int incx, 263 double *result) { 264 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 265 const double *, int, double *); 266 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDnrm2_v2"); 267 if (!func_ptr) return GetSymbolNotFoundError(); 268 return func_ptr(handle, n, x, incx, result); 269} 270 271cublasStatus_t CUBLASWINAPI cublasScnrm2_v2(cublasHandle_t handle, int n, 272 const cuComplex *x, int incx, 273 float *result) { 274 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 275 cublasHandle_t, int, const cuComplex *, int, float *); 276 static auto func_ptr = LoadSymbol<FuncPtr>("cublasScnrm2_v2"); 277 if (!func_ptr) return GetSymbolNotFoundError(); 278 return func_ptr(handle, n, x, incx, result); 279} 280 281cublasStatus_t CUBLASWINAPI cublasDznrm2_v2(cublasHandle_t handle, int n, 282 const cuDoubleComplex *x, int incx, 283 double *result) { 284 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 285 cublasHandle_t, int, const cuDoubleComplex *, int, double *); 286 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDznrm2_v2"); 287 if (!func_ptr) return GetSymbolNotFoundError(); 288 return func_ptr(handle, n, x, incx, result); 289} 290 291cublasStatus_t CUBLASWINAPI cublasDotEx(cublasHandle_t handle, int n, 292 const void *x, cudaDataType xType, 293 int incx, const void *y, 294 cudaDataType yType, int incy, 295 void *result, cudaDataType resultType, 296 cudaDataType executionType) { 297 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 298 cublasHandle_t, int, const void *, cudaDataType, int, const void *, 299 cudaDataType, int, void *, cudaDataType, cudaDataType); 300 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDotEx"); 301 if (!func_ptr) return GetSymbolNotFoundError(); 302 return func_ptr(handle, n, x, xType, incx, y, yType, incy, result, resultType, 303 executionType); 304} 305 306cublasStatus_t CUBLASWINAPI cublasDotcEx(cublasHandle_t handle, int n, 307 const void *x, cudaDataType xType, 308 int incx, const void *y, 309 cudaDataType yType, int incy, 310 void *result, cudaDataType resultType, 311 cudaDataType executionType) { 312 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 313 cublasHandle_t, int, const void *, cudaDataType, int, const void *, 314 cudaDataType, int, void *, cudaDataType, cudaDataType); 315 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDotcEx"); 316 if (!func_ptr) return GetSymbolNotFoundError(); 317 return func_ptr(handle, n, x, xType, incx, y, yType, incy, result, resultType, 318 executionType); 319} 320 321cublasStatus_t CUBLASWINAPI cublasSdot_v2(cublasHandle_t handle, int n, 322 const float *x, int incx, 323 const float *y, int incy, 324 float *result) { 325 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 326 cublasHandle_t, int, const float *, int, const float *, int, float *); 327 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSdot_v2"); 328 if (!func_ptr) return GetSymbolNotFoundError(); 329 return func_ptr(handle, n, x, incx, y, incy, result); 330} 331 332cublasStatus_t CUBLASWINAPI cublasDdot_v2(cublasHandle_t handle, int n, 333 const double *x, int incx, 334 const double *y, int incy, 335 double *result) { 336 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 337 cublasHandle_t, int, const double *, int, const double *, int, double *); 338 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDdot_v2"); 339 if (!func_ptr) return GetSymbolNotFoundError(); 340 return func_ptr(handle, n, x, incx, y, incy, result); 341} 342 343cublasStatus_t CUBLASWINAPI cublasCdotu_v2(cublasHandle_t handle, int n, 344 const cuComplex *x, int incx, 345 const cuComplex *y, int incy, 346 cuComplex *result) { 347 using FuncPtr = 348 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, const cuComplex *, 349 int, const cuComplex *, int, cuComplex *); 350 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCdotu_v2"); 351 if (!func_ptr) return GetSymbolNotFoundError(); 352 return func_ptr(handle, n, x, incx, y, incy, result); 353} 354 355cublasStatus_t CUBLASWINAPI cublasCdotc_v2(cublasHandle_t handle, int n, 356 const cuComplex *x, int incx, 357 const cuComplex *y, int incy, 358 cuComplex *result) { 359 using FuncPtr = 360 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, const cuComplex *, 361 int, const cuComplex *, int, cuComplex *); 362 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCdotc_v2"); 363 if (!func_ptr) return GetSymbolNotFoundError(); 364 return func_ptr(handle, n, x, incx, y, incy, result); 365} 366 367cublasStatus_t CUBLASWINAPI cublasZdotu_v2(cublasHandle_t handle, int n, 368 const cuDoubleComplex *x, int incx, 369 const cuDoubleComplex *y, int incy, 370 cuDoubleComplex *result) { 371 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 372 cublasHandle_t, int, const cuDoubleComplex *, int, 373 const cuDoubleComplex *, int, cuDoubleComplex *); 374 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdotu_v2"); 375 if (!func_ptr) return GetSymbolNotFoundError(); 376 return func_ptr(handle, n, x, incx, y, incy, result); 377} 378 379cublasStatus_t CUBLASWINAPI cublasZdotc_v2(cublasHandle_t handle, int n, 380 const cuDoubleComplex *x, int incx, 381 const cuDoubleComplex *y, int incy, 382 cuDoubleComplex *result) { 383 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 384 cublasHandle_t, int, const cuDoubleComplex *, int, 385 const cuDoubleComplex *, int, cuDoubleComplex *); 386 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdotc_v2"); 387 if (!func_ptr) return GetSymbolNotFoundError(); 388 return func_ptr(handle, n, x, incx, y, incy, result); 389} 390 391cublasStatus_t CUBLASWINAPI 392cublasScalEx(cublasHandle_t handle, int n, 393 const void *alpha, /* host or device pointer */ 394 cudaDataType alphaType, void *x, cudaDataType xType, int incx, 395 cudaDataType executionType) { 396 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 397 cublasHandle_t, int, const void *, cudaDataType, void *, cudaDataType, 398 int, cudaDataType); 399 static auto func_ptr = LoadSymbol<FuncPtr>("cublasScalEx"); 400 if (!func_ptr) return GetSymbolNotFoundError(); 401 return func_ptr(handle, n, alpha, alphaType, x, xType, incx, executionType); 402} 403 404cublasStatus_t CUBLASWINAPI 405cublasSscal_v2(cublasHandle_t handle, int n, 406 const float *alpha, /* host or device pointer */ 407 float *x, int incx) { 408 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 409 const float *, float *, int); 410 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSscal_v2"); 411 if (!func_ptr) return GetSymbolNotFoundError(); 412 return func_ptr(handle, n, alpha, x, incx); 413} 414 415cublasStatus_t CUBLASWINAPI 416cublasDscal_v2(cublasHandle_t handle, int n, 417 const double *alpha, /* host or device pointer */ 418 double *x, int incx) { 419 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 420 const double *, double *, int); 421 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDscal_v2"); 422 if (!func_ptr) return GetSymbolNotFoundError(); 423 return func_ptr(handle, n, alpha, x, incx); 424} 425 426cublasStatus_t CUBLASWINAPI 427cublasCscal_v2(cublasHandle_t handle, int n, 428 const cuComplex *alpha, /* host or device pointer */ 429 cuComplex *x, int incx) { 430 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 431 cublasHandle_t, int, const cuComplex *, cuComplex *, int); 432 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCscal_v2"); 433 if (!func_ptr) return GetSymbolNotFoundError(); 434 return func_ptr(handle, n, alpha, x, incx); 435} 436 437cublasStatus_t CUBLASWINAPI 438cublasCsscal_v2(cublasHandle_t handle, int n, 439 const float *alpha, /* host or device pointer */ 440 cuComplex *x, int incx) { 441 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 442 cublasHandle_t, int, const float *, cuComplex *, int); 443 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsscal_v2"); 444 if (!func_ptr) return GetSymbolNotFoundError(); 445 return func_ptr(handle, n, alpha, x, incx); 446} 447 448cublasStatus_t CUBLASWINAPI 449cublasZscal_v2(cublasHandle_t handle, int n, 450 const cuDoubleComplex *alpha, /* host or device pointer */ 451 cuDoubleComplex *x, int incx) { 452 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 453 cublasHandle_t, int, const cuDoubleComplex *, cuDoubleComplex *, int); 454 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZscal_v2"); 455 if (!func_ptr) return GetSymbolNotFoundError(); 456 return func_ptr(handle, n, alpha, x, incx); 457} 458 459cublasStatus_t CUBLASWINAPI 460cublasZdscal_v2(cublasHandle_t handle, int n, 461 const double *alpha, /* host or device pointer */ 462 cuDoubleComplex *x, int incx) { 463 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 464 cublasHandle_t, int, const double *, cuDoubleComplex *, int); 465 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdscal_v2"); 466 if (!func_ptr) return GetSymbolNotFoundError(); 467 return func_ptr(handle, n, alpha, x, incx); 468} 469 470cublasStatus_t CUBLASWINAPI cublasAxpyEx( 471 cublasHandle_t handle, int n, 472 const void *alpha, /* host or device pointer */ 473 cudaDataType alphaType, const void *x, cudaDataType xType, int incx, 474 void *y, cudaDataType yType, int incy, cudaDataType executiontype) { 475 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 476 cublasHandle_t, int, const void *, cudaDataType, const void *, 477 cudaDataType, int, void *, cudaDataType, int, cudaDataType); 478 static auto func_ptr = LoadSymbol<FuncPtr>("cublasAxpyEx"); 479 if (!func_ptr) return GetSymbolNotFoundError(); 480 return func_ptr(handle, n, alpha, alphaType, x, xType, incx, y, yType, incy, 481 executiontype); 482} 483 484cublasStatus_t CUBLASWINAPI 485cublasSaxpy_v2(cublasHandle_t handle, int n, 486 const float *alpha, /* host or device pointer */ 487 const float *x, int incx, float *y, int incy) { 488 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 489 cublasHandle_t, int, const float *, const float *, int, float *, int); 490 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSaxpy_v2"); 491 if (!func_ptr) return GetSymbolNotFoundError(); 492 return func_ptr(handle, n, alpha, x, incx, y, incy); 493} 494 495cublasStatus_t CUBLASWINAPI 496cublasDaxpy_v2(cublasHandle_t handle, int n, 497 const double *alpha, /* host or device pointer */ 498 const double *x, int incx, double *y, int incy) { 499 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 500 cublasHandle_t, int, const double *, const double *, int, double *, int); 501 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDaxpy_v2"); 502 if (!func_ptr) return GetSymbolNotFoundError(); 503 return func_ptr(handle, n, alpha, x, incx, y, incy); 504} 505 506cublasStatus_t CUBLASWINAPI 507cublasCaxpy_v2(cublasHandle_t handle, int n, 508 const cuComplex *alpha, /* host or device pointer */ 509 const cuComplex *x, int incx, cuComplex *y, int incy) { 510 using FuncPtr = 511 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, const cuComplex *, 512 const cuComplex *, int, cuComplex *, int); 513 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCaxpy_v2"); 514 if (!func_ptr) return GetSymbolNotFoundError(); 515 return func_ptr(handle, n, alpha, x, incx, y, incy); 516} 517 518cublasStatus_t CUBLASWINAPI cublasZaxpy_v2( 519 cublasHandle_t handle, int n, 520 const cuDoubleComplex *alpha, /* host or device pointer */ 521 const cuDoubleComplex *x, int incx, cuDoubleComplex *y, int incy) { 522 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 523 cublasHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *, 524 int, cuDoubleComplex *, int); 525 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZaxpy_v2"); 526 if (!func_ptr) return GetSymbolNotFoundError(); 527 return func_ptr(handle, n, alpha, x, incx, y, incy); 528} 529 530cublasStatus_t CUBLASWINAPI cublasCopyEx(cublasHandle_t handle, int n, 531 const void *x, cudaDataType xType, 532 int incx, void *y, cudaDataType yType, 533 int incy) { 534 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 535 cublasHandle_t, int, const void *, cudaDataType, int, void *, 536 cudaDataType, int); 537 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCopyEx"); 538 if (!func_ptr) return GetSymbolNotFoundError(); 539 return func_ptr(handle, n, x, xType, incx, y, yType, incy); 540} 541 542cublasStatus_t CUBLASWINAPI cublasScopy_v2(cublasHandle_t handle, int n, 543 const float *x, int incx, float *y, 544 int incy) { 545 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 546 cublasHandle_t, int, const float *, int, float *, int); 547 static auto func_ptr = LoadSymbol<FuncPtr>("cublasScopy_v2"); 548 if (!func_ptr) return GetSymbolNotFoundError(); 549 return func_ptr(handle, n, x, incx, y, incy); 550} 551 552cublasStatus_t CUBLASWINAPI cublasDcopy_v2(cublasHandle_t handle, int n, 553 const double *x, int incx, double *y, 554 int incy) { 555 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 556 cublasHandle_t, int, const double *, int, double *, int); 557 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDcopy_v2"); 558 if (!func_ptr) return GetSymbolNotFoundError(); 559 return func_ptr(handle, n, x, incx, y, incy); 560} 561 562cublasStatus_t CUBLASWINAPI cublasCcopy_v2(cublasHandle_t handle, int n, 563 const cuComplex *x, int incx, 564 cuComplex *y, int incy) { 565 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 566 cublasHandle_t, int, const cuComplex *, int, cuComplex *, int); 567 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCcopy_v2"); 568 if (!func_ptr) return GetSymbolNotFoundError(); 569 return func_ptr(handle, n, x, incx, y, incy); 570} 571 572cublasStatus_t CUBLASWINAPI cublasZcopy_v2(cublasHandle_t handle, int n, 573 const cuDoubleComplex *x, int incx, 574 cuDoubleComplex *y, int incy) { 575 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 576 const cuDoubleComplex *, int, 577 cuDoubleComplex *, int); 578 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZcopy_v2"); 579 if (!func_ptr) return GetSymbolNotFoundError(); 580 return func_ptr(handle, n, x, incx, y, incy); 581} 582 583cublasStatus_t CUBLASWINAPI cublasSswap_v2(cublasHandle_t handle, int n, 584 float *x, int incx, float *y, 585 int incy) { 586 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, float *, 587 int, float *, int); 588 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSswap_v2"); 589 if (!func_ptr) return GetSymbolNotFoundError(); 590 return func_ptr(handle, n, x, incx, y, incy); 591} 592 593cublasStatus_t CUBLASWINAPI cublasDswap_v2(cublasHandle_t handle, int n, 594 double *x, int incx, double *y, 595 int incy) { 596 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, double *, 597 int, double *, int); 598 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDswap_v2"); 599 if (!func_ptr) return GetSymbolNotFoundError(); 600 return func_ptr(handle, n, x, incx, y, incy); 601} 602 603cublasStatus_t CUBLASWINAPI cublasCswap_v2(cublasHandle_t handle, int n, 604 cuComplex *x, int incx, cuComplex *y, 605 int incy) { 606 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 607 cublasHandle_t, int, cuComplex *, int, cuComplex *, int); 608 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCswap_v2"); 609 if (!func_ptr) return GetSymbolNotFoundError(); 610 return func_ptr(handle, n, x, incx, y, incy); 611} 612 613cublasStatus_t CUBLASWINAPI cublasZswap_v2(cublasHandle_t handle, int n, 614 cuDoubleComplex *x, int incx, 615 cuDoubleComplex *y, int incy) { 616 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 617 cublasHandle_t, int, cuDoubleComplex *, int, cuDoubleComplex *, int); 618 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZswap_v2"); 619 if (!func_ptr) return GetSymbolNotFoundError(); 620 return func_ptr(handle, n, x, incx, y, incy); 621} 622 623cublasStatus_t CUBLASWINAPI cublasSwapEx(cublasHandle_t handle, int n, void *x, 624 cudaDataType xType, int incx, void *y, 625 cudaDataType yType, int incy) { 626 using FuncPtr = 627 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, void *, cudaDataType, 628 int, void *, cudaDataType, int); 629 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSwapEx"); 630 if (!func_ptr) return GetSymbolNotFoundError(); 631 return func_ptr(handle, n, x, xType, incx, y, yType, incy); 632} 633 634cublasStatus_t CUBLASWINAPI cublasIsamax_v2(cublasHandle_t handle, int n, 635 const float *x, int incx, 636 int *result) { 637 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 638 const float *, int, int *); 639 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIsamax_v2"); 640 if (!func_ptr) return GetSymbolNotFoundError(); 641 return func_ptr(handle, n, x, incx, result); 642} 643 644cublasStatus_t CUBLASWINAPI cublasIdamax_v2(cublasHandle_t handle, int n, 645 const double *x, int incx, 646 int *result) { 647 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 648 const double *, int, int *); 649 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIdamax_v2"); 650 if (!func_ptr) return GetSymbolNotFoundError(); 651 return func_ptr(handle, n, x, incx, result); 652} 653 654cublasStatus_t CUBLASWINAPI cublasIcamax_v2(cublasHandle_t handle, int n, 655 const cuComplex *x, int incx, 656 int *result) { 657 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 658 const cuComplex *, int, int *); 659 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIcamax_v2"); 660 if (!func_ptr) return GetSymbolNotFoundError(); 661 return func_ptr(handle, n, x, incx, result); 662} 663 664cublasStatus_t CUBLASWINAPI cublasIzamax_v2(cublasHandle_t handle, int n, 665 const cuDoubleComplex *x, int incx, 666 int *result) { 667 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 668 cublasHandle_t, int, const cuDoubleComplex *, int, int *); 669 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIzamax_v2"); 670 if (!func_ptr) return GetSymbolNotFoundError(); 671 return func_ptr(handle, n, x, incx, result); 672} 673 674cublasStatus_t CUBLASWINAPI cublasIamaxEx( 675 cublasHandle_t handle, int n, const void *x, cudaDataType xType, int incx, 676 int *result /* host or device pointer */ 677) { 678 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 679 cublasHandle_t, int, const void *, cudaDataType, int, int *); 680 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIamaxEx"); 681 if (!func_ptr) return GetSymbolNotFoundError(); 682 return func_ptr(handle, n, x, xType, incx, result); 683} 684 685cublasStatus_t CUBLASWINAPI cublasIsamin_v2(cublasHandle_t handle, int n, 686 const float *x, int incx, 687 int *result) { 688 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 689 const float *, int, int *); 690 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIsamin_v2"); 691 if (!func_ptr) return GetSymbolNotFoundError(); 692 return func_ptr(handle, n, x, incx, result); 693} 694 695cublasStatus_t CUBLASWINAPI cublasIdamin_v2(cublasHandle_t handle, int n, 696 const double *x, int incx, 697 int *result) { 698 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 699 const double *, int, int *); 700 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIdamin_v2"); 701 if (!func_ptr) return GetSymbolNotFoundError(); 702 return func_ptr(handle, n, x, incx, result); 703} 704 705cublasStatus_t CUBLASWINAPI cublasIcamin_v2(cublasHandle_t handle, int n, 706 const cuComplex *x, int incx, 707 int *result) { 708 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 709 const cuComplex *, int, int *); 710 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIcamin_v2"); 711 if (!func_ptr) return GetSymbolNotFoundError(); 712 return func_ptr(handle, n, x, incx, result); 713} 714 715cublasStatus_t CUBLASWINAPI cublasIzamin_v2(cublasHandle_t handle, int n, 716 const cuDoubleComplex *x, int incx, 717 int *result) { 718 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 719 cublasHandle_t, int, const cuDoubleComplex *, int, int *); 720 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIzamin_v2"); 721 if (!func_ptr) return GetSymbolNotFoundError(); 722 return func_ptr(handle, n, x, incx, result); 723} 724 725cublasStatus_t CUBLASWINAPI cublasIaminEx( 726 cublasHandle_t handle, int n, const void *x, cudaDataType xType, int incx, 727 int *result /* host or device pointer */ 728) { 729 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 730 cublasHandle_t, int, const void *, cudaDataType, int, int *); 731 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIaminEx"); 732 if (!func_ptr) return GetSymbolNotFoundError(); 733 return func_ptr(handle, n, x, xType, incx, result); 734} 735 736cublasStatus_t CUBLASWINAPI cublasAsumEx( 737 cublasHandle_t handle, int n, const void *x, cudaDataType xType, int incx, 738 void *result, cudaDataType resultType, /* host or device pointer */ 739 cudaDataType executiontype) { 740 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 741 cublasHandle_t, int, const void *, cudaDataType, int, void *, 742 cudaDataType, cudaDataType); 743 static auto func_ptr = LoadSymbol<FuncPtr>("cublasAsumEx"); 744 if (!func_ptr) return GetSymbolNotFoundError(); 745 return func_ptr(handle, n, x, xType, incx, result, resultType, executiontype); 746} 747 748cublasStatus_t CUBLASWINAPI cublasSasum_v2(cublasHandle_t handle, int n, 749 const float *x, int incx, 750 float *result) { 751 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 752 const float *, int, float *); 753 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSasum_v2"); 754 if (!func_ptr) return GetSymbolNotFoundError(); 755 return func_ptr(handle, n, x, incx, result); 756} 757 758cublasStatus_t CUBLASWINAPI cublasDasum_v2(cublasHandle_t handle, int n, 759 const double *x, int incx, 760 double *result) { 761 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, 762 const double *, int, double *); 763 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDasum_v2"); 764 if (!func_ptr) return GetSymbolNotFoundError(); 765 return func_ptr(handle, n, x, incx, result); 766} 767 768cublasStatus_t CUBLASWINAPI cublasScasum_v2(cublasHandle_t handle, int n, 769 const cuComplex *x, int incx, 770 float *result) { 771 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 772 cublasHandle_t, int, const cuComplex *, int, float *); 773 static auto func_ptr = LoadSymbol<FuncPtr>("cublasScasum_v2"); 774 if (!func_ptr) return GetSymbolNotFoundError(); 775 return func_ptr(handle, n, x, incx, result); 776} 777 778cublasStatus_t CUBLASWINAPI cublasDzasum_v2(cublasHandle_t handle, int n, 779 const cuDoubleComplex *x, int incx, 780 double *result) { 781 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 782 cublasHandle_t, int, const cuDoubleComplex *, int, double *); 783 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDzasum_v2"); 784 if (!func_ptr) return GetSymbolNotFoundError(); 785 return func_ptr(handle, n, x, incx, result); 786} 787 788cublasStatus_t CUBLASWINAPI 789cublasSrot_v2(cublasHandle_t handle, int n, float *x, int incx, float *y, 790 int incy, const float *c, /* host or device pointer */ 791 const float *s) { 792 using FuncPtr = 793 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, float *, int, float *, 794 int, const float *, const float *); 795 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrot_v2"); 796 if (!func_ptr) return GetSymbolNotFoundError(); 797 return func_ptr(handle, n, x, incx, y, incy, c, s); 798} 799 800cublasStatus_t CUBLASWINAPI 801cublasDrot_v2(cublasHandle_t handle, int n, double *x, int incx, double *y, 802 int incy, const double *c, /* host or device pointer */ 803 const double *s) { 804 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 805 cublasHandle_t, int, double *, int, double *, int, const double *, 806 const double *); 807 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrot_v2"); 808 if (!func_ptr) return GetSymbolNotFoundError(); 809 return func_ptr(handle, n, x, incx, y, incy, c, s); 810} 811 812cublasStatus_t CUBLASWINAPI cublasCrot_v2( 813 cublasHandle_t handle, int n, cuComplex *x, int incx, cuComplex *y, 814 int incy, const float *c, /* host or device pointer */ 815 const cuComplex *s) { 816 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 817 cublasHandle_t, int, cuComplex *, int, cuComplex *, int, const float *, 818 const cuComplex *); 819 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCrot_v2"); 820 if (!func_ptr) return GetSymbolNotFoundError(); 821 return func_ptr(handle, n, x, incx, y, incy, c, s); 822} 823 824cublasStatus_t CUBLASWINAPI cublasCsrot_v2( 825 cublasHandle_t handle, int n, cuComplex *x, int incx, cuComplex *y, 826 int incy, const float *c, /* host or device pointer */ 827 const float *s) { 828 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 829 cublasHandle_t, int, cuComplex *, int, cuComplex *, int, const float *, 830 const float *); 831 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsrot_v2"); 832 if (!func_ptr) return GetSymbolNotFoundError(); 833 return func_ptr(handle, n, x, incx, y, incy, c, s); 834} 835 836cublasStatus_t CUBLASWINAPI cublasZrot_v2( 837 cublasHandle_t handle, int n, cuDoubleComplex *x, int incx, 838 cuDoubleComplex *y, int incy, const double *c, /* host or device pointer */ 839 const cuDoubleComplex *s) { 840 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 841 cublasHandle_t, int, cuDoubleComplex *, int, cuDoubleComplex *, int, 842 const double *, const cuDoubleComplex *); 843 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZrot_v2"); 844 if (!func_ptr) return GetSymbolNotFoundError(); 845 return func_ptr(handle, n, x, incx, y, incy, c, s); 846} 847 848cublasStatus_t CUBLASWINAPI cublasZdrot_v2( 849 cublasHandle_t handle, int n, cuDoubleComplex *x, int incx, 850 cuDoubleComplex *y, int incy, const double *c, /* host or device pointer */ 851 const double *s) { 852 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 853 cublasHandle_t, int, cuDoubleComplex *, int, cuDoubleComplex *, int, 854 const double *, const double *); 855 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdrot_v2"); 856 if (!func_ptr) return GetSymbolNotFoundError(); 857 return func_ptr(handle, n, x, incx, y, incy, c, s); 858} 859 860cublasStatus_t CUBLASWINAPI 861cublasRotEx(cublasHandle_t handle, int n, void *x, cudaDataType xType, int incx, 862 void *y, cudaDataType yType, int incy, 863 const void *c, /* host or device pointer */ 864 const void *s, cudaDataType csType, cudaDataType executiontype) { 865 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 866 cublasHandle_t, int, void *, cudaDataType, int, void *, cudaDataType, int, 867 const void *, const void *, cudaDataType, cudaDataType); 868 static auto func_ptr = LoadSymbol<FuncPtr>("cublasRotEx"); 869 if (!func_ptr) return GetSymbolNotFoundError(); 870 return func_ptr(handle, n, x, xType, incx, y, yType, incy, c, s, csType, 871 executiontype); 872} 873 874cublasStatus_t CUBLASWINAPI 875cublasSrotg_v2(cublasHandle_t handle, float *a, /* host or device pointer */ 876 float *b, /* host or device pointer */ 877 float *c, /* host or device pointer */ 878 float *s) { 879 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, float *, 880 float *, float *, float *); 881 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotg_v2"); 882 if (!func_ptr) return GetSymbolNotFoundError(); 883 return func_ptr(handle, a, b, c, s); 884} 885 886cublasStatus_t CUBLASWINAPI 887cublasDrotg_v2(cublasHandle_t handle, double *a, /* host or device pointer */ 888 double *b, /* host or device pointer */ 889 double *c, /* host or device pointer */ 890 double *s) { 891 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, double *, 892 double *, double *, double *); 893 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotg_v2"); 894 if (!func_ptr) return GetSymbolNotFoundError(); 895 return func_ptr(handle, a, b, c, s); 896} 897 898cublasStatus_t CUBLASWINAPI 899cublasCrotg_v2(cublasHandle_t handle, cuComplex *a, /* host or device pointer */ 900 cuComplex *b, /* host or device pointer */ 901 float *c, /* host or device pointer */ 902 cuComplex *s) { 903 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 904 cublasHandle_t, cuComplex *, cuComplex *, float *, cuComplex *); 905 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCrotg_v2"); 906 if (!func_ptr) return GetSymbolNotFoundError(); 907 return func_ptr(handle, a, b, c, s); 908} 909 910cublasStatus_t CUBLASWINAPI cublasZrotg_v2( 911 cublasHandle_t handle, cuDoubleComplex *a, /* host or device pointer */ 912 cuDoubleComplex *b, /* host or device pointer */ 913 double *c, /* host or device pointer */ 914 cuDoubleComplex *s) { 915 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 916 cublasHandle_t, cuDoubleComplex *, cuDoubleComplex *, double *, 917 cuDoubleComplex *); 918 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZrotg_v2"); 919 if (!func_ptr) return GetSymbolNotFoundError(); 920 return func_ptr(handle, a, b, c, s); 921} 922 923cublasStatus_t CUBLASWINAPI cublasRotgEx(cublasHandle_t handle, 924 void *a, /* host or device pointer */ 925 void *b, /* host or device pointer */ 926 cudaDataType abType, 927 void *c, /* host or device pointer */ 928 void *s, /* host or device pointer */ 929 cudaDataType csType, 930 cudaDataType executiontype) { 931 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, void *, void *, 932 cudaDataType, void *, void *, 933 cudaDataType, cudaDataType); 934 static auto func_ptr = LoadSymbol<FuncPtr>("cublasRotgEx"); 935 if (!func_ptr) return GetSymbolNotFoundError(); 936 return func_ptr(handle, a, b, abType, c, s, csType, executiontype); 937} 938 939cublasStatus_t CUBLASWINAPI cublasSrotm_v2(cublasHandle_t handle, int n, 940 float *x, int incx, float *y, 941 int incy, const float *param) { 942 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 943 cublasHandle_t, int, float *, int, float *, int, const float *); 944 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotm_v2"); 945 if (!func_ptr) return GetSymbolNotFoundError(); 946 return func_ptr(handle, n, x, incx, y, incy, param); 947} 948 949cublasStatus_t CUBLASWINAPI cublasDrotm_v2(cublasHandle_t handle, int n, 950 double *x, int incx, double *y, 951 int incy, const double *param) { 952 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 953 cublasHandle_t, int, double *, int, double *, int, const double *); 954 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotm_v2"); 955 if (!func_ptr) return GetSymbolNotFoundError(); 956 return func_ptr(handle, n, x, incx, y, incy, param); 957} 958 959cublasStatus_t CUBLASWINAPI 960cublasRotmEx(cublasHandle_t handle, int n, void *x, cudaDataType xType, 961 int incx, void *y, cudaDataType yType, int incy, 962 const void *param, /* host or device pointer */ 963 cudaDataType paramType, cudaDataType executiontype) { 964 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 965 cublasHandle_t, int, void *, cudaDataType, int, void *, cudaDataType, int, 966 const void *, cudaDataType, cudaDataType); 967 static auto func_ptr = LoadSymbol<FuncPtr>("cublasRotmEx"); 968 if (!func_ptr) return GetSymbolNotFoundError(); 969 return func_ptr(handle, n, x, xType, incx, y, yType, incy, param, paramType, 970 executiontype); 971} 972 973cublasStatus_t CUBLASWINAPI 974cublasSrotmg_v2(cublasHandle_t handle, float *d1, /* host or device pointer */ 975 float *d2, /* host or device pointer */ 976 float *x1, /* host or device pointer */ 977 const float *y1, /* host or device pointer */ 978 float *param) { 979 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 980 cublasHandle_t, float *, float *, float *, const float *, float *); 981 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotmg_v2"); 982 if (!func_ptr) return GetSymbolNotFoundError(); 983 return func_ptr(handle, d1, d2, x1, y1, param); 984} 985 986cublasStatus_t CUBLASWINAPI 987cublasDrotmg_v2(cublasHandle_t handle, double *d1, /* host or device pointer */ 988 double *d2, /* host or device pointer */ 989 double *x1, /* host or device pointer */ 990 const double *y1, /* host or device pointer */ 991 double *param) { 992 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 993 cublasHandle_t, double *, double *, double *, const double *, double *); 994 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotmg_v2"); 995 if (!func_ptr) return GetSymbolNotFoundError(); 996 return func_ptr(handle, d1, d2, x1, y1, param); 997} 998 999cublasStatus_t CUBLASWINAPI 1000cublasRotmgEx(cublasHandle_t handle, void *d1, /* host or device pointer */ 1001 cudaDataType d1Type, void *d2, /* host or device pointer */ 1002 cudaDataType d2Type, void *x1, /* host or device pointer */ 1003 cudaDataType x1Type, const void *y1, /* host or device pointer */ 1004 cudaDataType y1Type, void *param, /* host or device pointer */ 1005 cudaDataType paramType, cudaDataType executiontype) { 1006 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1007 cublasHandle_t, void *, cudaDataType, void *, cudaDataType, void *, 1008 cudaDataType, const void *, cudaDataType, void *, cudaDataType, 1009 cudaDataType); 1010 static auto func_ptr = LoadSymbol<FuncPtr>("cublasRotmgEx"); 1011 if (!func_ptr) return GetSymbolNotFoundError(); 1012 return func_ptr(handle, d1, d1Type, d2, d2Type, x1, x1Type, y1, y1Type, param, 1013 paramType, executiontype); 1014} 1015 1016cublasStatus_t CUBLASWINAPI 1017cublasSgemv_v2(cublasHandle_t handle, cublasOperation_t trans, int m, int n, 1018 const float *alpha, /* host or device pointer */ 1019 const float *A, int lda, const float *x, int incx, 1020 const float *beta, /* host or device pointer */ 1021 float *y, int incy) { 1022 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1023 cublasHandle_t, cublasOperation_t, int, int, const float *, const float *, 1024 int, const float *, int, const float *, float *, int); 1025 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemv_v2"); 1026 if (!func_ptr) return GetSymbolNotFoundError(); 1027 return func_ptr(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy); 1028} 1029 1030cublasStatus_t CUBLASWINAPI 1031cublasDgemv_v2(cublasHandle_t handle, cublasOperation_t trans, int m, int n, 1032 const double *alpha, /* host or device pointer */ 1033 const double *A, int lda, const double *x, int incx, 1034 const double *beta, /* host or device pointer */ 1035 double *y, int incy) { 1036 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1037 cublasHandle_t, cublasOperation_t, int, int, const double *, 1038 const double *, int, const double *, int, const double *, double *, int); 1039 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemv_v2"); 1040 if (!func_ptr) return GetSymbolNotFoundError(); 1041 return func_ptr(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy); 1042} 1043 1044cublasStatus_t CUBLASWINAPI 1045cublasCgemv_v2(cublasHandle_t handle, cublasOperation_t trans, int m, int n, 1046 const cuComplex *alpha, /* host or device pointer */ 1047 const cuComplex *A, int lda, const cuComplex *x, int incx, 1048 const cuComplex *beta, /* host or device pointer */ 1049 cuComplex *y, int incy) { 1050 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1051 cublasHandle_t, cublasOperation_t, int, int, const cuComplex *, 1052 const cuComplex *, int, const cuComplex *, int, const cuComplex *, 1053 cuComplex *, int); 1054 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemv_v2"); 1055 if (!func_ptr) return GetSymbolNotFoundError(); 1056 return func_ptr(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy); 1057} 1058 1059cublasStatus_t CUBLASWINAPI cublasZgemv_v2( 1060 cublasHandle_t handle, cublasOperation_t trans, int m, int n, 1061 const cuDoubleComplex *alpha, /* host or device pointer */ 1062 const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, 1063 const cuDoubleComplex *beta, /* host or device pointer */ 1064 cuDoubleComplex *y, int incy) { 1065 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1066 cublasHandle_t, cublasOperation_t, int, int, const cuDoubleComplex *, 1067 const cuDoubleComplex *, int, const cuDoubleComplex *, int, 1068 const cuDoubleComplex *, cuDoubleComplex *, int); 1069 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemv_v2"); 1070 if (!func_ptr) return GetSymbolNotFoundError(); 1071 return func_ptr(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy); 1072} 1073 1074cublasStatus_t CUBLASWINAPI 1075cublasSgbmv_v2(cublasHandle_t handle, cublasOperation_t trans, int m, int n, 1076 int kl, int ku, const float *alpha, /* host or device pointer */ 1077 const float *A, int lda, const float *x, int incx, 1078 const float *beta, /* host or device pointer */ 1079 float *y, int incy) { 1080 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1081 cublasHandle_t, cublasOperation_t, int, int, int, int, const float *, 1082 const float *, int, const float *, int, const float *, float *, int); 1083 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgbmv_v2"); 1084 if (!func_ptr) return GetSymbolNotFoundError(); 1085 return func_ptr(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, 1086 incy); 1087} 1088 1089cublasStatus_t CUBLASWINAPI 1090cublasDgbmv_v2(cublasHandle_t handle, cublasOperation_t trans, int m, int n, 1091 int kl, int ku, const double *alpha, /* host or device pointer */ 1092 const double *A, int lda, const double *x, int incx, 1093 const double *beta, /* host or device pointer */ 1094 double *y, int incy) { 1095 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1096 cublasHandle_t, cublasOperation_t, int, int, int, int, const double *, 1097 const double *, int, const double *, int, const double *, double *, int); 1098 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgbmv_v2"); 1099 if (!func_ptr) return GetSymbolNotFoundError(); 1100 return func_ptr(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, 1101 incy); 1102} 1103 1104cublasStatus_t CUBLASWINAPI cublasCgbmv_v2( 1105 cublasHandle_t handle, cublasOperation_t trans, int m, int n, int kl, 1106 int ku, const cuComplex *alpha, /* host or device pointer */ 1107 const cuComplex *A, int lda, const cuComplex *x, int incx, 1108 const cuComplex *beta, /* host or device pointer */ 1109 cuComplex *y, int incy) { 1110 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1111 cublasHandle_t, cublasOperation_t, int, int, int, int, const cuComplex *, 1112 const cuComplex *, int, const cuComplex *, int, const cuComplex *, 1113 cuComplex *, int); 1114 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgbmv_v2"); 1115 if (!func_ptr) return GetSymbolNotFoundError(); 1116 return func_ptr(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, 1117 incy); 1118} 1119 1120cublasStatus_t CUBLASWINAPI cublasZgbmv_v2( 1121 cublasHandle_t handle, cublasOperation_t trans, int m, int n, int kl, 1122 int ku, const cuDoubleComplex *alpha, /* host or device pointer */ 1123 const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, 1124 const cuDoubleComplex *beta, /* host or device pointer */ 1125 cuDoubleComplex *y, int incy) { 1126 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1127 cublasHandle_t, cublasOperation_t, int, int, int, int, 1128 const cuDoubleComplex *, const cuDoubleComplex *, int, 1129 const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *, 1130 int); 1131 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgbmv_v2"); 1132 if (!func_ptr) return GetSymbolNotFoundError(); 1133 return func_ptr(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, 1134 incy); 1135} 1136 1137cublasStatus_t CUBLASWINAPI cublasStrmv_v2( 1138 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 1139 cublasDiagType_t diag, int n, const float *A, int lda, float *x, int incx) { 1140 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1141 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1142 int, const float *, int, float *, int); 1143 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrmv_v2"); 1144 if (!func_ptr) return GetSymbolNotFoundError(); 1145 return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx); 1146} 1147 1148cublasStatus_t CUBLASWINAPI cublasDtrmv_v2(cublasHandle_t handle, 1149 cublasFillMode_t uplo, 1150 cublasOperation_t trans, 1151 cublasDiagType_t diag, int n, 1152 const double *A, int lda, double *x, 1153 int incx) { 1154 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1155 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1156 int, const double *, int, double *, int); 1157 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrmv_v2"); 1158 if (!func_ptr) return GetSymbolNotFoundError(); 1159 return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx); 1160} 1161 1162cublasStatus_t CUBLASWINAPI cublasCtrmv_v2(cublasHandle_t handle, 1163 cublasFillMode_t uplo, 1164 cublasOperation_t trans, 1165 cublasDiagType_t diag, int n, 1166 const cuComplex *A, int lda, 1167 cuComplex *x, int incx) { 1168 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1169 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1170 int, const cuComplex *, int, cuComplex *, int); 1171 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrmv_v2"); 1172 if (!func_ptr) return GetSymbolNotFoundError(); 1173 return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx); 1174} 1175 1176cublasStatus_t CUBLASWINAPI cublasZtrmv_v2(cublasHandle_t handle, 1177 cublasFillMode_t uplo, 1178 cublasOperation_t trans, 1179 cublasDiagType_t diag, int n, 1180 const cuDoubleComplex *A, int lda, 1181 cuDoubleComplex *x, int incx) { 1182 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1183 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1184 int, const cuDoubleComplex *, int, cuDoubleComplex *, int); 1185 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrmv_v2"); 1186 if (!func_ptr) return GetSymbolNotFoundError(); 1187 return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx); 1188} 1189 1190cublasStatus_t CUBLASWINAPI cublasStbmv_v2(cublasHandle_t handle, 1191 cublasFillMode_t uplo, 1192 cublasOperation_t trans, 1193 cublasDiagType_t diag, int n, int k, 1194 const float *A, int lda, float *x, 1195 int incx) { 1196 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1197 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1198 int, int, const float *, int, float *, int); 1199 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStbmv_v2"); 1200 if (!func_ptr) return GetSymbolNotFoundError(); 1201 return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx); 1202} 1203 1204cublasStatus_t CUBLASWINAPI cublasDtbmv_v2(cublasHandle_t handle, 1205 cublasFillMode_t uplo, 1206 cublasOperation_t trans, 1207 cublasDiagType_t diag, int n, int k, 1208 const double *A, int lda, double *x, 1209 int incx) { 1210 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1211 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1212 int, int, const double *, int, double *, int); 1213 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtbmv_v2"); 1214 if (!func_ptr) return GetSymbolNotFoundError(); 1215 return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx); 1216} 1217 1218cublasStatus_t CUBLASWINAPI cublasCtbmv_v2(cublasHandle_t handle, 1219 cublasFillMode_t uplo, 1220 cublasOperation_t trans, 1221 cublasDiagType_t diag, int n, int k, 1222 const cuComplex *A, int lda, 1223 cuComplex *x, int incx) { 1224 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1225 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1226 int, int, const cuComplex *, int, cuComplex *, int); 1227 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtbmv_v2"); 1228 if (!func_ptr) return GetSymbolNotFoundError(); 1229 return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx); 1230} 1231 1232cublasStatus_t CUBLASWINAPI cublasZtbmv_v2(cublasHandle_t handle, 1233 cublasFillMode_t uplo, 1234 cublasOperation_t trans, 1235 cublasDiagType_t diag, int n, int k, 1236 const cuDoubleComplex *A, int lda, 1237 cuDoubleComplex *x, int incx) { 1238 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1239 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1240 int, int, const cuDoubleComplex *, int, cuDoubleComplex *, int); 1241 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtbmv_v2"); 1242 if (!func_ptr) return GetSymbolNotFoundError(); 1243 return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx); 1244} 1245 1246cublasStatus_t CUBLASWINAPI cublasStpmv_v2( 1247 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 1248 cublasDiagType_t diag, int n, const float *AP, float *x, int incx) { 1249 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1250 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1251 int, const float *, float *, int); 1252 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStpmv_v2"); 1253 if (!func_ptr) return GetSymbolNotFoundError(); 1254 return func_ptr(handle, uplo, trans, diag, n, AP, x, incx); 1255} 1256 1257cublasStatus_t CUBLASWINAPI cublasDtpmv_v2( 1258 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 1259 cublasDiagType_t diag, int n, const double *AP, double *x, int incx) { 1260 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1261 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1262 int, const double *, double *, int); 1263 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtpmv_v2"); 1264 if (!func_ptr) return GetSymbolNotFoundError(); 1265 return func_ptr(handle, uplo, trans, diag, n, AP, x, incx); 1266} 1267 1268cublasStatus_t CUBLASWINAPI cublasCtpmv_v2( 1269 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 1270 cublasDiagType_t diag, int n, const cuComplex *AP, cuComplex *x, int incx) { 1271 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1272 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1273 int, const cuComplex *, cuComplex *, int); 1274 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtpmv_v2"); 1275 if (!func_ptr) return GetSymbolNotFoundError(); 1276 return func_ptr(handle, uplo, trans, diag, n, AP, x, incx); 1277} 1278 1279cublasStatus_t CUBLASWINAPI cublasZtpmv_v2(cublasHandle_t handle, 1280 cublasFillMode_t uplo, 1281 cublasOperation_t trans, 1282 cublasDiagType_t diag, int n, 1283 const cuDoubleComplex *AP, 1284 cuDoubleComplex *x, int incx) { 1285 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1286 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1287 int, const cuDoubleComplex *, cuDoubleComplex *, int); 1288 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtpmv_v2"); 1289 if (!func_ptr) return GetSymbolNotFoundError(); 1290 return func_ptr(handle, uplo, trans, diag, n, AP, x, incx); 1291} 1292 1293cublasStatus_t CUBLASWINAPI cublasStrsv_v2( 1294 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 1295 cublasDiagType_t diag, int n, const float *A, int lda, float *x, int incx) { 1296 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1297 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1298 int, const float *, int, float *, int); 1299 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrsv_v2"); 1300 if (!func_ptr) return GetSymbolNotFoundError(); 1301 return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx); 1302} 1303 1304cublasStatus_t CUBLASWINAPI cublasDtrsv_v2(cublasHandle_t handle, 1305 cublasFillMode_t uplo, 1306 cublasOperation_t trans, 1307 cublasDiagType_t diag, int n, 1308 const double *A, int lda, double *x, 1309 int incx) { 1310 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1311 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1312 int, const double *, int, double *, int); 1313 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrsv_v2"); 1314 if (!func_ptr) return GetSymbolNotFoundError(); 1315 return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx); 1316} 1317 1318cublasStatus_t CUBLASWINAPI cublasCtrsv_v2(cublasHandle_t handle, 1319 cublasFillMode_t uplo, 1320 cublasOperation_t trans, 1321 cublasDiagType_t diag, int n, 1322 const cuComplex *A, int lda, 1323 cuComplex *x, int incx) { 1324 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1325 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1326 int, const cuComplex *, int, cuComplex *, int); 1327 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrsv_v2"); 1328 if (!func_ptr) return GetSymbolNotFoundError(); 1329 return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx); 1330} 1331 1332cublasStatus_t CUBLASWINAPI cublasZtrsv_v2(cublasHandle_t handle, 1333 cublasFillMode_t uplo, 1334 cublasOperation_t trans, 1335 cublasDiagType_t diag, int n, 1336 const cuDoubleComplex *A, int lda, 1337 cuDoubleComplex *x, int incx) { 1338 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1339 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1340 int, const cuDoubleComplex *, int, cuDoubleComplex *, int); 1341 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrsv_v2"); 1342 if (!func_ptr) return GetSymbolNotFoundError(); 1343 return func_ptr(handle, uplo, trans, diag, n, A, lda, x, incx); 1344} 1345 1346cublasStatus_t CUBLASWINAPI cublasStpsv_v2( 1347 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 1348 cublasDiagType_t diag, int n, const float *AP, float *x, int incx) { 1349 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1350 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1351 int, const float *, float *, int); 1352 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStpsv_v2"); 1353 if (!func_ptr) return GetSymbolNotFoundError(); 1354 return func_ptr(handle, uplo, trans, diag, n, AP, x, incx); 1355} 1356 1357cublasStatus_t CUBLASWINAPI cublasDtpsv_v2( 1358 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 1359 cublasDiagType_t diag, int n, const double *AP, double *x, int incx) { 1360 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1361 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1362 int, const double *, double *, int); 1363 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtpsv_v2"); 1364 if (!func_ptr) return GetSymbolNotFoundError(); 1365 return func_ptr(handle, uplo, trans, diag, n, AP, x, incx); 1366} 1367 1368cublasStatus_t CUBLASWINAPI cublasCtpsv_v2( 1369 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 1370 cublasDiagType_t diag, int n, const cuComplex *AP, cuComplex *x, int incx) { 1371 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1372 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1373 int, const cuComplex *, cuComplex *, int); 1374 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtpsv_v2"); 1375 if (!func_ptr) return GetSymbolNotFoundError(); 1376 return func_ptr(handle, uplo, trans, diag, n, AP, x, incx); 1377} 1378 1379cublasStatus_t CUBLASWINAPI cublasZtpsv_v2(cublasHandle_t handle, 1380 cublasFillMode_t uplo, 1381 cublasOperation_t trans, 1382 cublasDiagType_t diag, int n, 1383 const cuDoubleComplex *AP, 1384 cuDoubleComplex *x, int incx) { 1385 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1386 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1387 int, const cuDoubleComplex *, cuDoubleComplex *, int); 1388 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtpsv_v2"); 1389 if (!func_ptr) return GetSymbolNotFoundError(); 1390 return func_ptr(handle, uplo, trans, diag, n, AP, x, incx); 1391} 1392 1393cublasStatus_t CUBLASWINAPI cublasStbsv_v2(cublasHandle_t handle, 1394 cublasFillMode_t uplo, 1395 cublasOperation_t trans, 1396 cublasDiagType_t diag, int n, int k, 1397 const float *A, int lda, float *x, 1398 int incx) { 1399 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1400 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1401 int, int, const float *, int, float *, int); 1402 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStbsv_v2"); 1403 if (!func_ptr) return GetSymbolNotFoundError(); 1404 return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx); 1405} 1406 1407cublasStatus_t CUBLASWINAPI cublasDtbsv_v2(cublasHandle_t handle, 1408 cublasFillMode_t uplo, 1409 cublasOperation_t trans, 1410 cublasDiagType_t diag, int n, int k, 1411 const double *A, int lda, double *x, 1412 int incx) { 1413 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1414 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1415 int, int, const double *, int, double *, int); 1416 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtbsv_v2"); 1417 if (!func_ptr) return GetSymbolNotFoundError(); 1418 return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx); 1419} 1420 1421cublasStatus_t CUBLASWINAPI cublasCtbsv_v2(cublasHandle_t handle, 1422 cublasFillMode_t uplo, 1423 cublasOperation_t trans, 1424 cublasDiagType_t diag, int n, int k, 1425 const cuComplex *A, int lda, 1426 cuComplex *x, int incx) { 1427 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1428 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1429 int, int, const cuComplex *, int, cuComplex *, int); 1430 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtbsv_v2"); 1431 if (!func_ptr) return GetSymbolNotFoundError(); 1432 return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx); 1433} 1434 1435cublasStatus_t CUBLASWINAPI cublasZtbsv_v2(cublasHandle_t handle, 1436 cublasFillMode_t uplo, 1437 cublasOperation_t trans, 1438 cublasDiagType_t diag, int n, int k, 1439 const cuDoubleComplex *A, int lda, 1440 cuDoubleComplex *x, int incx) { 1441 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1442 cublasHandle_t, cublasFillMode_t, cublasOperation_t, cublasDiagType_t, 1443 int, int, const cuDoubleComplex *, int, cuDoubleComplex *, int); 1444 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtbsv_v2"); 1445 if (!func_ptr) return GetSymbolNotFoundError(); 1446 return func_ptr(handle, uplo, trans, diag, n, k, A, lda, x, incx); 1447} 1448 1449cublasStatus_t CUBLASWINAPI 1450cublasSsymv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1451 const float *alpha, /* host or device pointer */ 1452 const float *A, int lda, const float *x, int incx, 1453 const float *beta, /* host or device pointer */ 1454 float *y, int incy) { 1455 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1456 cublasHandle_t, cublasFillMode_t, int, const float *, const float *, int, 1457 const float *, int, const float *, float *, int); 1458 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsymv_v2"); 1459 if (!func_ptr) return GetSymbolNotFoundError(); 1460 return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy); 1461} 1462 1463cublasStatus_t CUBLASWINAPI 1464cublasDsymv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1465 const double *alpha, /* host or device pointer */ 1466 const double *A, int lda, const double *x, int incx, 1467 const double *beta, /* host or device pointer */ 1468 double *y, int incy) { 1469 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1470 cublasHandle_t, cublasFillMode_t, int, const double *, const double *, 1471 int, const double *, int, const double *, double *, int); 1472 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsymv_v2"); 1473 if (!func_ptr) return GetSymbolNotFoundError(); 1474 return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy); 1475} 1476 1477cublasStatus_t CUBLASWINAPI 1478cublasCsymv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1479 const cuComplex *alpha, /* host or device pointer */ 1480 const cuComplex *A, int lda, const cuComplex *x, int incx, 1481 const cuComplex *beta, /* host or device pointer */ 1482 cuComplex *y, int incy) { 1483 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1484 cublasHandle_t, cublasFillMode_t, int, const cuComplex *, 1485 const cuComplex *, int, const cuComplex *, int, const cuComplex *, 1486 cuComplex *, int); 1487 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsymv_v2"); 1488 if (!func_ptr) return GetSymbolNotFoundError(); 1489 return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy); 1490} 1491 1492cublasStatus_t CUBLASWINAPI cublasZsymv_v2( 1493 cublasHandle_t handle, cublasFillMode_t uplo, int n, 1494 const cuDoubleComplex *alpha, /* host or device pointer */ 1495 const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, 1496 const cuDoubleComplex *beta, /* host or device pointer */ 1497 cuDoubleComplex *y, int incy) { 1498 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1499 cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, 1500 const cuDoubleComplex *, int, const cuDoubleComplex *, int, 1501 const cuDoubleComplex *, cuDoubleComplex *, int); 1502 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsymv_v2"); 1503 if (!func_ptr) return GetSymbolNotFoundError(); 1504 return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy); 1505} 1506 1507cublasStatus_t CUBLASWINAPI 1508cublasChemv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1509 const cuComplex *alpha, /* host or device pointer */ 1510 const cuComplex *A, int lda, const cuComplex *x, int incx, 1511 const cuComplex *beta, /* host or device pointer */ 1512 cuComplex *y, int incy) { 1513 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1514 cublasHandle_t, cublasFillMode_t, int, const cuComplex *, 1515 const cuComplex *, int, const cuComplex *, int, const cuComplex *, 1516 cuComplex *, int); 1517 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChemv_v2"); 1518 if (!func_ptr) return GetSymbolNotFoundError(); 1519 return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy); 1520} 1521 1522cublasStatus_t CUBLASWINAPI cublasZhemv_v2( 1523 cublasHandle_t handle, cublasFillMode_t uplo, int n, 1524 const cuDoubleComplex *alpha, /* host or device pointer */ 1525 const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, 1526 const cuDoubleComplex *beta, /* host or device pointer */ 1527 cuDoubleComplex *y, int incy) { 1528 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1529 cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, 1530 const cuDoubleComplex *, int, const cuDoubleComplex *, int, 1531 const cuDoubleComplex *, cuDoubleComplex *, int); 1532 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhemv_v2"); 1533 if (!func_ptr) return GetSymbolNotFoundError(); 1534 return func_ptr(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy); 1535} 1536 1537cublasStatus_t CUBLASWINAPI 1538cublasSsbmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, int k, 1539 const float *alpha, /* host or device pointer */ 1540 const float *A, int lda, const float *x, int incx, 1541 const float *beta, /* host or device pointer */ 1542 float *y, int incy) { 1543 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1544 cublasHandle_t, cublasFillMode_t, int, int, const float *, const float *, 1545 int, const float *, int, const float *, float *, int); 1546 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsbmv_v2"); 1547 if (!func_ptr) return GetSymbolNotFoundError(); 1548 return func_ptr(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy); 1549} 1550 1551cublasStatus_t CUBLASWINAPI 1552cublasDsbmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, int k, 1553 const double *alpha, /* host or device pointer */ 1554 const double *A, int lda, const double *x, int incx, 1555 const double *beta, /* host or device pointer */ 1556 double *y, int incy) { 1557 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1558 cublasHandle_t, cublasFillMode_t, int, int, const double *, 1559 const double *, int, const double *, int, const double *, double *, int); 1560 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsbmv_v2"); 1561 if (!func_ptr) return GetSymbolNotFoundError(); 1562 return func_ptr(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy); 1563} 1564 1565cublasStatus_t CUBLASWINAPI 1566cublasChbmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, int k, 1567 const cuComplex *alpha, /* host or device pointer */ 1568 const cuComplex *A, int lda, const cuComplex *x, int incx, 1569 const cuComplex *beta, /* host or device pointer */ 1570 cuComplex *y, int incy) { 1571 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1572 cublasHandle_t, cublasFillMode_t, int, int, const cuComplex *, 1573 const cuComplex *, int, const cuComplex *, int, const cuComplex *, 1574 cuComplex *, int); 1575 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChbmv_v2"); 1576 if (!func_ptr) return GetSymbolNotFoundError(); 1577 return func_ptr(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy); 1578} 1579 1580cublasStatus_t CUBLASWINAPI cublasZhbmv_v2( 1581 cublasHandle_t handle, cublasFillMode_t uplo, int n, int k, 1582 const cuDoubleComplex *alpha, /* host or device pointer */ 1583 const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, 1584 const cuDoubleComplex *beta, /* host or device pointer */ 1585 cuDoubleComplex *y, int incy) { 1586 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1587 cublasHandle_t, cublasFillMode_t, int, int, const cuDoubleComplex *, 1588 const cuDoubleComplex *, int, const cuDoubleComplex *, int, 1589 const cuDoubleComplex *, cuDoubleComplex *, int); 1590 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhbmv_v2"); 1591 if (!func_ptr) return GetSymbolNotFoundError(); 1592 return func_ptr(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy); 1593} 1594 1595cublasStatus_t CUBLASWINAPI 1596cublasSspmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1597 const float *alpha, /* host or device pointer */ 1598 const float *AP, const float *x, int incx, 1599 const float *beta, /* host or device pointer */ 1600 float *y, int incy) { 1601 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1602 cublasHandle_t, cublasFillMode_t, int, const float *, const float *, 1603 const float *, int, const float *, float *, int); 1604 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspmv_v2"); 1605 if (!func_ptr) return GetSymbolNotFoundError(); 1606 return func_ptr(handle, uplo, n, alpha, AP, x, incx, beta, y, incy); 1607} 1608 1609cublasStatus_t CUBLASWINAPI 1610cublasDspmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1611 const double *alpha, /* host or device pointer */ 1612 const double *AP, const double *x, int incx, 1613 const double *beta, /* host or device pointer */ 1614 double *y, int incy) { 1615 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1616 cublasHandle_t, cublasFillMode_t, int, const double *, const double *, 1617 const double *, int, const double *, double *, int); 1618 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspmv_v2"); 1619 if (!func_ptr) return GetSymbolNotFoundError(); 1620 return func_ptr(handle, uplo, n, alpha, AP, x, incx, beta, y, incy); 1621} 1622 1623cublasStatus_t CUBLASWINAPI 1624cublasChpmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1625 const cuComplex *alpha, /* host or device pointer */ 1626 const cuComplex *AP, const cuComplex *x, int incx, 1627 const cuComplex *beta, /* host or device pointer */ 1628 cuComplex *y, int incy) { 1629 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1630 cublasHandle_t, cublasFillMode_t, int, const cuComplex *, 1631 const cuComplex *, const cuComplex *, int, const cuComplex *, cuComplex *, 1632 int); 1633 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpmv_v2"); 1634 if (!func_ptr) return GetSymbolNotFoundError(); 1635 return func_ptr(handle, uplo, n, alpha, AP, x, incx, beta, y, incy); 1636} 1637 1638cublasStatus_t CUBLASWINAPI 1639cublasZhpmv_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1640 const cuDoubleComplex *alpha, /* host or device pointer */ 1641 const cuDoubleComplex *AP, const cuDoubleComplex *x, int incx, 1642 const cuDoubleComplex *beta, /* host or device pointer */ 1643 cuDoubleComplex *y, int incy) { 1644 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1645 cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, 1646 const cuDoubleComplex *, const cuDoubleComplex *, int, 1647 const cuDoubleComplex *, cuDoubleComplex *, int); 1648 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpmv_v2"); 1649 if (!func_ptr) return GetSymbolNotFoundError(); 1650 return func_ptr(handle, uplo, n, alpha, AP, x, incx, beta, y, incy); 1651} 1652 1653cublasStatus_t CUBLASWINAPI cublasSger_v2( 1654 cublasHandle_t handle, int m, int n, 1655 const float *alpha, /* host or device pointer */ 1656 const float *x, int incx, const float *y, int incy, float *A, int lda) { 1657 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1658 cublasHandle_t, int, int, const float *, const float *, int, 1659 const float *, int, float *, int); 1660 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSger_v2"); 1661 if (!func_ptr) return GetSymbolNotFoundError(); 1662 return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda); 1663} 1664 1665cublasStatus_t CUBLASWINAPI cublasDger_v2( 1666 cublasHandle_t handle, int m, int n, 1667 const double *alpha, /* host or device pointer */ 1668 const double *x, int incx, const double *y, int incy, double *A, int lda) { 1669 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1670 cublasHandle_t, int, int, const double *, const double *, int, 1671 const double *, int, double *, int); 1672 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDger_v2"); 1673 if (!func_ptr) return GetSymbolNotFoundError(); 1674 return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda); 1675} 1676 1677cublasStatus_t CUBLASWINAPI 1678cublasCgeru_v2(cublasHandle_t handle, int m, int n, 1679 const cuComplex *alpha, /* host or device pointer */ 1680 const cuComplex *x, int incx, const cuComplex *y, int incy, 1681 cuComplex *A, int lda) { 1682 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1683 cublasHandle_t, int, int, const cuComplex *, const cuComplex *, int, 1684 const cuComplex *, int, cuComplex *, int); 1685 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgeru_v2"); 1686 if (!func_ptr) return GetSymbolNotFoundError(); 1687 return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda); 1688} 1689 1690cublasStatus_t CUBLASWINAPI 1691cublasCgerc_v2(cublasHandle_t handle, int m, int n, 1692 const cuComplex *alpha, /* host or device pointer */ 1693 const cuComplex *x, int incx, const cuComplex *y, int incy, 1694 cuComplex *A, int lda) { 1695 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1696 cublasHandle_t, int, int, const cuComplex *, const cuComplex *, int, 1697 const cuComplex *, int, cuComplex *, int); 1698 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgerc_v2"); 1699 if (!func_ptr) return GetSymbolNotFoundError(); 1700 return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda); 1701} 1702 1703cublasStatus_t CUBLASWINAPI 1704cublasZgeru_v2(cublasHandle_t handle, int m, int n, 1705 const cuDoubleComplex *alpha, /* host or device pointer */ 1706 const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, 1707 int incy, cuDoubleComplex *A, int lda) { 1708 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1709 cublasHandle_t, int, int, const cuDoubleComplex *, 1710 const cuDoubleComplex *, int, const cuDoubleComplex *, int, 1711 cuDoubleComplex *, int); 1712 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgeru_v2"); 1713 if (!func_ptr) return GetSymbolNotFoundError(); 1714 return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda); 1715} 1716 1717cublasStatus_t CUBLASWINAPI 1718cublasZgerc_v2(cublasHandle_t handle, int m, int n, 1719 const cuDoubleComplex *alpha, /* host or device pointer */ 1720 const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, 1721 int incy, cuDoubleComplex *A, int lda) { 1722 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1723 cublasHandle_t, int, int, const cuDoubleComplex *, 1724 const cuDoubleComplex *, int, const cuDoubleComplex *, int, 1725 cuDoubleComplex *, int); 1726 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgerc_v2"); 1727 if (!func_ptr) return GetSymbolNotFoundError(); 1728 return func_ptr(handle, m, n, alpha, x, incx, y, incy, A, lda); 1729} 1730 1731cublasStatus_t CUBLASWINAPI 1732cublasSsyr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1733 const float *alpha, /* host or device pointer */ 1734 const float *x, int incx, float *A, int lda) { 1735 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1736 cublasHandle_t, cublasFillMode_t, int, const float *, const float *, int, 1737 float *, int); 1738 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr_v2"); 1739 if (!func_ptr) return GetSymbolNotFoundError(); 1740 return func_ptr(handle, uplo, n, alpha, x, incx, A, lda); 1741} 1742 1743cublasStatus_t CUBLASWINAPI 1744cublasDsyr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1745 const double *alpha, /* host or device pointer */ 1746 const double *x, int incx, double *A, int lda) { 1747 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1748 cublasHandle_t, cublasFillMode_t, int, const double *, const double *, 1749 int, double *, int); 1750 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr_v2"); 1751 if (!func_ptr) return GetSymbolNotFoundError(); 1752 return func_ptr(handle, uplo, n, alpha, x, incx, A, lda); 1753} 1754 1755cublasStatus_t CUBLASWINAPI 1756cublasCsyr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1757 const cuComplex *alpha, /* host or device pointer */ 1758 const cuComplex *x, int incx, cuComplex *A, int lda) { 1759 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1760 cublasHandle_t, cublasFillMode_t, int, const cuComplex *, 1761 const cuComplex *, int, cuComplex *, int); 1762 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyr_v2"); 1763 if (!func_ptr) return GetSymbolNotFoundError(); 1764 return func_ptr(handle, uplo, n, alpha, x, incx, A, lda); 1765} 1766 1767cublasStatus_t CUBLASWINAPI 1768cublasZsyr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1769 const cuDoubleComplex *alpha, /* host or device pointer */ 1770 const cuDoubleComplex *x, int incx, cuDoubleComplex *A, int lda) { 1771 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1772 cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, 1773 const cuDoubleComplex *, int, cuDoubleComplex *, int); 1774 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyr_v2"); 1775 if (!func_ptr) return GetSymbolNotFoundError(); 1776 return func_ptr(handle, uplo, n, alpha, x, incx, A, lda); 1777} 1778 1779cublasStatus_t CUBLASWINAPI 1780cublasCher_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1781 const float *alpha, /* host or device pointer */ 1782 const cuComplex *x, int incx, cuComplex *A, int lda) { 1783 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1784 cublasHandle_t, cublasFillMode_t, int, const float *, const cuComplex *, 1785 int, cuComplex *, int); 1786 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher_v2"); 1787 if (!func_ptr) return GetSymbolNotFoundError(); 1788 return func_ptr(handle, uplo, n, alpha, x, incx, A, lda); 1789} 1790 1791cublasStatus_t CUBLASWINAPI 1792cublasZher_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1793 const double *alpha, /* host or device pointer */ 1794 const cuDoubleComplex *x, int incx, cuDoubleComplex *A, int lda) { 1795 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1796 cublasHandle_t, cublasFillMode_t, int, const double *, 1797 const cuDoubleComplex *, int, cuDoubleComplex *, int); 1798 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher_v2"); 1799 if (!func_ptr) return GetSymbolNotFoundError(); 1800 return func_ptr(handle, uplo, n, alpha, x, incx, A, lda); 1801} 1802 1803cublasStatus_t CUBLASWINAPI 1804cublasSspr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1805 const float *alpha, /* host or device pointer */ 1806 const float *x, int incx, float *AP) { 1807 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1808 cublasHandle_t, cublasFillMode_t, int, const float *, const float *, int, 1809 float *); 1810 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspr_v2"); 1811 if (!func_ptr) return GetSymbolNotFoundError(); 1812 return func_ptr(handle, uplo, n, alpha, x, incx, AP); 1813} 1814 1815cublasStatus_t CUBLASWINAPI 1816cublasDspr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1817 const double *alpha, /* host or device pointer */ 1818 const double *x, int incx, double *AP) { 1819 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1820 cublasHandle_t, cublasFillMode_t, int, const double *, const double *, 1821 int, double *); 1822 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspr_v2"); 1823 if (!func_ptr) return GetSymbolNotFoundError(); 1824 return func_ptr(handle, uplo, n, alpha, x, incx, AP); 1825} 1826 1827cublasStatus_t CUBLASWINAPI 1828cublasChpr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1829 const float *alpha, /* host or device pointer */ 1830 const cuComplex *x, int incx, cuComplex *AP) { 1831 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1832 cublasHandle_t, cublasFillMode_t, int, const float *, const cuComplex *, 1833 int, cuComplex *); 1834 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpr_v2"); 1835 if (!func_ptr) return GetSymbolNotFoundError(); 1836 return func_ptr(handle, uplo, n, alpha, x, incx, AP); 1837} 1838 1839cublasStatus_t CUBLASWINAPI 1840cublasZhpr_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1841 const double *alpha, /* host or device pointer */ 1842 const cuDoubleComplex *x, int incx, cuDoubleComplex *AP) { 1843 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1844 cublasHandle_t, cublasFillMode_t, int, const double *, 1845 const cuDoubleComplex *, int, cuDoubleComplex *); 1846 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpr_v2"); 1847 if (!func_ptr) return GetSymbolNotFoundError(); 1848 return func_ptr(handle, uplo, n, alpha, x, incx, AP); 1849} 1850 1851cublasStatus_t CUBLASWINAPI cublasSsyr2_v2( 1852 cublasHandle_t handle, cublasFillMode_t uplo, int n, 1853 const float *alpha, /* host or device pointer */ 1854 const float *x, int incx, const float *y, int incy, float *A, int lda) { 1855 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1856 cublasHandle_t, cublasFillMode_t, int, const float *, const float *, int, 1857 const float *, int, float *, int); 1858 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr2_v2"); 1859 if (!func_ptr) return GetSymbolNotFoundError(); 1860 return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda); 1861} 1862 1863cublasStatus_t CUBLASWINAPI cublasDsyr2_v2( 1864 cublasHandle_t handle, cublasFillMode_t uplo, int n, 1865 const double *alpha, /* host or device pointer */ 1866 const double *x, int incx, const double *y, int incy, double *A, int lda) { 1867 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1868 cublasHandle_t, cublasFillMode_t, int, const double *, const double *, 1869 int, const double *, int, double *, int); 1870 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr2_v2"); 1871 if (!func_ptr) return GetSymbolNotFoundError(); 1872 return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda); 1873} 1874 1875cublasStatus_t CUBLASWINAPI 1876cublasCsyr2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1877 const cuComplex *alpha, /* host or device pointer */ 1878 const cuComplex *x, int incx, const cuComplex *y, int incy, 1879 cuComplex *A, int lda) { 1880 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1881 cublasHandle_t, cublasFillMode_t, int, const cuComplex *, 1882 const cuComplex *, int, const cuComplex *, int, cuComplex *, int); 1883 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyr2_v2"); 1884 if (!func_ptr) return GetSymbolNotFoundError(); 1885 return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda); 1886} 1887 1888cublasStatus_t CUBLASWINAPI 1889cublasZsyr2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1890 const cuDoubleComplex *alpha, /* host or device pointer */ 1891 const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, 1892 int incy, cuDoubleComplex *A, int lda) { 1893 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1894 cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, 1895 const cuDoubleComplex *, int, const cuDoubleComplex *, int, 1896 cuDoubleComplex *, int); 1897 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyr2_v2"); 1898 if (!func_ptr) return GetSymbolNotFoundError(); 1899 return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda); 1900} 1901 1902cublasStatus_t CUBLASWINAPI 1903cublasCher2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1904 const cuComplex *alpha, /* host or device pointer */ 1905 const cuComplex *x, int incx, const cuComplex *y, int incy, 1906 cuComplex *A, int lda) { 1907 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1908 cublasHandle_t, cublasFillMode_t, int, const cuComplex *, 1909 const cuComplex *, int, const cuComplex *, int, cuComplex *, int); 1910 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher2_v2"); 1911 if (!func_ptr) return GetSymbolNotFoundError(); 1912 return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda); 1913} 1914 1915cublasStatus_t CUBLASWINAPI 1916cublasZher2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1917 const cuDoubleComplex *alpha, /* host or device pointer */ 1918 const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, 1919 int incy, cuDoubleComplex *A, int lda) { 1920 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1921 cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, 1922 const cuDoubleComplex *, int, const cuDoubleComplex *, int, 1923 cuDoubleComplex *, int); 1924 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher2_v2"); 1925 if (!func_ptr) return GetSymbolNotFoundError(); 1926 return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, A, lda); 1927} 1928 1929cublasStatus_t CUBLASWINAPI 1930cublasSspr2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1931 const float *alpha, /* host or device pointer */ 1932 const float *x, int incx, const float *y, int incy, float *AP) { 1933 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1934 cublasHandle_t, cublasFillMode_t, int, const float *, const float *, int, 1935 const float *, int, float *); 1936 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspr2_v2"); 1937 if (!func_ptr) return GetSymbolNotFoundError(); 1938 return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, AP); 1939} 1940 1941cublasStatus_t CUBLASWINAPI cublasDspr2_v2( 1942 cublasHandle_t handle, cublasFillMode_t uplo, int n, 1943 const double *alpha, /* host or device pointer */ 1944 const double *x, int incx, const double *y, int incy, double *AP) { 1945 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1946 cublasHandle_t, cublasFillMode_t, int, const double *, const double *, 1947 int, const double *, int, double *); 1948 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspr2_v2"); 1949 if (!func_ptr) return GetSymbolNotFoundError(); 1950 return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, AP); 1951} 1952 1953cublasStatus_t CUBLASWINAPI cublasChpr2_v2( 1954 cublasHandle_t handle, cublasFillMode_t uplo, int n, 1955 const cuComplex *alpha, /* host or device pointer */ 1956 const cuComplex *x, int incx, const cuComplex *y, int incy, cuComplex *AP) { 1957 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1958 cublasHandle_t, cublasFillMode_t, int, const cuComplex *, 1959 const cuComplex *, int, const cuComplex *, int, cuComplex *); 1960 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpr2_v2"); 1961 if (!func_ptr) return GetSymbolNotFoundError(); 1962 return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, AP); 1963} 1964 1965cublasStatus_t CUBLASWINAPI 1966cublasZhpr2_v2(cublasHandle_t handle, cublasFillMode_t uplo, int n, 1967 const cuDoubleComplex *alpha, /* host or device pointer */ 1968 const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, 1969 int incy, cuDoubleComplex *AP) { 1970 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1971 cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, 1972 const cuDoubleComplex *, int, const cuDoubleComplex *, int, 1973 cuDoubleComplex *); 1974 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpr2_v2"); 1975 if (!func_ptr) return GetSymbolNotFoundError(); 1976 return func_ptr(handle, uplo, n, alpha, x, incx, y, incy, AP); 1977} 1978 1979cublasStatus_t CUBLASWINAPI cublasSgemm_v2( 1980 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 1981 int m, int n, int k, const float *alpha, /* host or device pointer */ 1982 const float *A, int lda, const float *B, int ldb, 1983 const float *beta, /* host or device pointer */ 1984 float *C, int ldc) { 1985 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 1986 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 1987 const float *, const float *, int, const float *, int, const float *, 1988 float *, int); 1989 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemm_v2"); 1990 if (!func_ptr) return GetSymbolNotFoundError(); 1991 return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, 1992 C, ldc); 1993} 1994 1995cublasStatus_t CUBLASWINAPI cublasDgemm_v2( 1996 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 1997 int m, int n, int k, const double *alpha, /* host or device pointer */ 1998 const double *A, int lda, const double *B, int ldb, 1999 const double *beta, /* host or device pointer */ 2000 double *C, int ldc) { 2001 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2002 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2003 const double *, const double *, int, const double *, int, const double *, 2004 double *, int); 2005 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemm_v2"); 2006 if (!func_ptr) return GetSymbolNotFoundError(); 2007 return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, 2008 C, ldc); 2009} 2010 2011cublasStatus_t CUBLASWINAPI cublasCgemm_v2( 2012 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2013 int m, int n, int k, const cuComplex *alpha, /* host or device pointer */ 2014 const cuComplex *A, int lda, const cuComplex *B, int ldb, 2015 const cuComplex *beta, /* host or device pointer */ 2016 cuComplex *C, int ldc) { 2017 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2018 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2019 const cuComplex *, const cuComplex *, int, const cuComplex *, int, 2020 const cuComplex *, cuComplex *, int); 2021 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm_v2"); 2022 if (!func_ptr) return GetSymbolNotFoundError(); 2023 return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, 2024 C, ldc); 2025} 2026 2027cublasStatus_t CUBLASWINAPI cublasCgemm3m( 2028 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2029 int m, int n, int k, const cuComplex *alpha, /* host or device pointer */ 2030 const cuComplex *A, int lda, const cuComplex *B, int ldb, 2031 const cuComplex *beta, /* host or device pointer */ 2032 cuComplex *C, int ldc) { 2033 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2034 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2035 const cuComplex *, const cuComplex *, int, const cuComplex *, int, 2036 const cuComplex *, cuComplex *, int); 2037 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm3m"); 2038 if (!func_ptr) return GetSymbolNotFoundError(); 2039 return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, 2040 C, ldc); 2041} 2042 2043cublasStatus_t CUBLASWINAPI cublasCgemm3mEx( 2044 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2045 int m, int n, int k, const cuComplex *alpha, const void *A, 2046 cudaDataType Atype, int lda, const void *B, cudaDataType Btype, int ldb, 2047 const cuComplex *beta, void *C, cudaDataType Ctype, int ldc) { 2048 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2049 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2050 const cuComplex *, const void *, cudaDataType, int, const void *, 2051 cudaDataType, int, const cuComplex *, void *, cudaDataType, int); 2052 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm3mEx"); 2053 if (!func_ptr) return GetSymbolNotFoundError(); 2054 return func_ptr(handle, transa, transb, m, n, k, alpha, A, Atype, lda, B, 2055 Btype, ldb, beta, C, Ctype, ldc); 2056} 2057 2058cublasStatus_t CUBLASWINAPI cublasZgemm_v2( 2059 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2060 int m, int n, int k, 2061 const cuDoubleComplex *alpha, /* host or device pointer */ 2062 const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, 2063 const cuDoubleComplex *beta, /* host or device pointer */ 2064 cuDoubleComplex *C, int ldc) { 2065 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2066 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2067 const cuDoubleComplex *, const cuDoubleComplex *, int, 2068 const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *, 2069 int); 2070 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemm_v2"); 2071 if (!func_ptr) return GetSymbolNotFoundError(); 2072 return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, 2073 C, ldc); 2074} 2075 2076cublasStatus_t CUBLASWINAPI 2077cublasZgemm3m(cublasHandle_t handle, cublasOperation_t transa, 2078 cublasOperation_t transb, int m, int n, int k, 2079 const cuDoubleComplex *alpha, /* host or device pointer */ 2080 const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, 2081 int ldb, const cuDoubleComplex *beta, /* host or device pointer */ 2082 cuDoubleComplex *C, int ldc) { 2083 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2084 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2085 const cuDoubleComplex *, const cuDoubleComplex *, int, 2086 const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *, 2087 int); 2088 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemm3m"); 2089 if (!func_ptr) return GetSymbolNotFoundError(); 2090 return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, 2091 C, ldc); 2092} 2093 2094cublasStatus_t CUBLASWINAPI cublasSgemmEx( 2095 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2096 int m, int n, int k, const float *alpha, /* host or device pointer */ 2097 const void *A, cudaDataType Atype, int lda, const void *B, 2098 cudaDataType Btype, int ldb, const float *beta, /* host or device pointer */ 2099 void *C, cudaDataType Ctype, int ldc) { 2100 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2101 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2102 const float *, const void *, cudaDataType, int, const void *, 2103 cudaDataType, int, const float *, void *, cudaDataType, int); 2104 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemmEx"); 2105 if (!func_ptr) return GetSymbolNotFoundError(); 2106 return func_ptr(handle, transa, transb, m, n, k, alpha, A, Atype, lda, B, 2107 Btype, ldb, beta, C, Ctype, ldc); 2108} 2109 2110cublasStatus_t CUBLASWINAPI cublasGemmEx( 2111 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2112 int m, int n, int k, const void *alpha, /* host or device pointer */ 2113 const void *A, cudaDataType Atype, int lda, const void *B, 2114 cudaDataType Btype, int ldb, const void *beta, /* host or device pointer */ 2115 void *C, cudaDataType Ctype, int ldc, cublasComputeType_t computeType, 2116 cublasGemmAlgo_t algo) { 2117 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2118 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2119 const void *, const void *, cudaDataType, int, const void *, cudaDataType, 2120 int, const void *, void *, cudaDataType, int, cublasComputeType_t, 2121 cublasGemmAlgo_t); 2122 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGemmEx"); 2123 if (!func_ptr) return GetSymbolNotFoundError(); 2124 return func_ptr(handle, transa, transb, m, n, k, alpha, A, Atype, lda, B, 2125 Btype, ldb, beta, C, Ctype, ldc, computeType, algo); 2126} 2127 2128cublasStatus_t CUBLASWINAPI cublasCgemmEx( 2129 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2130 int m, int n, int k, const cuComplex *alpha, const void *A, 2131 cudaDataType Atype, int lda, const void *B, cudaDataType Btype, int ldb, 2132 const cuComplex *beta, void *C, cudaDataType Ctype, int ldc) { 2133 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2134 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2135 const cuComplex *, const void *, cudaDataType, int, const void *, 2136 cudaDataType, int, const cuComplex *, void *, cudaDataType, int); 2137 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemmEx"); 2138 if (!func_ptr) return GetSymbolNotFoundError(); 2139 return func_ptr(handle, transa, transb, m, n, k, alpha, A, Atype, lda, B, 2140 Btype, ldb, beta, C, Ctype, ldc); 2141} 2142 2143cublasStatus_t CUBLASWINAPI cublasUint8gemmBias( 2144 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2145 cublasOperation_t transc, int m, int n, int k, const unsigned char *A, 2146 int A_bias, int lda, const unsigned char *B, int B_bias, int ldb, 2147 unsigned char *C, int C_bias, int ldc, int C_mult, int C_shift) { 2148 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2149 cublasHandle_t, cublasOperation_t, cublasOperation_t, cublasOperation_t, 2150 int, int, int, const unsigned char *, int, int, const unsigned char *, 2151 int, int, unsigned char *, int, int, int, int); 2152 static auto func_ptr = LoadSymbol<FuncPtr>("cublasUint8gemmBias"); 2153 if (!func_ptr) return GetSymbolNotFoundError(); 2154 return func_ptr(handle, transa, transb, transc, m, n, k, A, A_bias, lda, B, 2155 B_bias, ldb, C, C_bias, ldc, C_mult, C_shift); 2156} 2157 2158cublasStatus_t CUBLASWINAPI cublasSsyrk_v2( 2159 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2160 int n, int k, const float *alpha, /* host or device pointer */ 2161 const float *A, int lda, const float *beta, /* host or device pointer */ 2162 float *C, int ldc) { 2163 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2164 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2165 const float *, const float *, int, const float *, float *, int); 2166 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyrk_v2"); 2167 if (!func_ptr) return GetSymbolNotFoundError(); 2168 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 2169} 2170 2171cublasStatus_t CUBLASWINAPI cublasDsyrk_v2( 2172 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2173 int n, int k, const double *alpha, /* host or device pointer */ 2174 const double *A, int lda, const double *beta, /* host or device pointer */ 2175 double *C, int ldc) { 2176 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2177 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2178 const double *, const double *, int, const double *, double *, int); 2179 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyrk_v2"); 2180 if (!func_ptr) return GetSymbolNotFoundError(); 2181 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 2182} 2183 2184cublasStatus_t CUBLASWINAPI cublasCsyrk_v2( 2185 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2186 int n, int k, const cuComplex *alpha, /* host or device pointer */ 2187 const cuComplex *A, int lda, 2188 const cuComplex *beta, /* host or device pointer */ 2189 cuComplex *C, int ldc) { 2190 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2191 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2192 const cuComplex *, const cuComplex *, int, const cuComplex *, cuComplex *, 2193 int); 2194 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyrk_v2"); 2195 if (!func_ptr) return GetSymbolNotFoundError(); 2196 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 2197} 2198 2199cublasStatus_t CUBLASWINAPI cublasZsyrk_v2( 2200 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2201 int n, int k, const cuDoubleComplex *alpha, /* host or device pointer */ 2202 const cuDoubleComplex *A, int lda, 2203 const cuDoubleComplex *beta, /* host or device pointer */ 2204 cuDoubleComplex *C, int ldc) { 2205 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2206 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2207 const cuDoubleComplex *, const cuDoubleComplex *, int, 2208 const cuDoubleComplex *, cuDoubleComplex *, int); 2209 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyrk_v2"); 2210 if (!func_ptr) return GetSymbolNotFoundError(); 2211 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 2212} 2213 2214cublasStatus_t CUBLASWINAPI cublasCsyrkEx( 2215 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2216 int n, int k, const cuComplex *alpha, /* host or device pointer */ 2217 const void *A, cudaDataType Atype, int lda, 2218 const cuComplex *beta, /* host or device pointer */ 2219 void *C, cudaDataType Ctype, int ldc) { 2220 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2221 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2222 const cuComplex *, const void *, cudaDataType, int, const cuComplex *, 2223 void *, cudaDataType, int); 2224 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyrkEx"); 2225 if (!func_ptr) return GetSymbolNotFoundError(); 2226 return func_ptr(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, 2227 Ctype, ldc); 2228} 2229 2230cublasStatus_t CUBLASWINAPI cublasCsyrk3mEx( 2231 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2232 int n, int k, const cuComplex *alpha, const void *A, cudaDataType Atype, 2233 int lda, const cuComplex *beta, void *C, cudaDataType Ctype, int ldc) { 2234 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2235 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2236 const cuComplex *, const void *, cudaDataType, int, const cuComplex *, 2237 void *, cudaDataType, int); 2238 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyrk3mEx"); 2239 if (!func_ptr) return GetSymbolNotFoundError(); 2240 return func_ptr(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, 2241 Ctype, ldc); 2242} 2243 2244cublasStatus_t CUBLASWINAPI cublasCherk_v2( 2245 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2246 int n, int k, const float *alpha, /* host or device pointer */ 2247 const cuComplex *A, int lda, const float *beta, /* host or device pointer */ 2248 cuComplex *C, int ldc) { 2249 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2250 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2251 const float *, const cuComplex *, int, const float *, cuComplex *, int); 2252 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCherk_v2"); 2253 if (!func_ptr) return GetSymbolNotFoundError(); 2254 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 2255} 2256 2257cublasStatus_t CUBLASWINAPI cublasZherk_v2( 2258 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2259 int n, int k, const double *alpha, /* host or device pointer */ 2260 const cuDoubleComplex *A, int lda, 2261 const double *beta, /* host or device pointer */ 2262 cuDoubleComplex *C, int ldc) { 2263 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2264 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2265 const double *, const cuDoubleComplex *, int, const double *, 2266 cuDoubleComplex *, int); 2267 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZherk_v2"); 2268 if (!func_ptr) return GetSymbolNotFoundError(); 2269 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 2270} 2271 2272cublasStatus_t CUBLASWINAPI cublasCherkEx( 2273 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2274 int n, int k, const float *alpha, /* host or device pointer */ 2275 const void *A, cudaDataType Atype, int lda, 2276 const float *beta, /* host or device pointer */ 2277 void *C, cudaDataType Ctype, int ldc) { 2278 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2279 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2280 const float *, const void *, cudaDataType, int, const float *, void *, 2281 cudaDataType, int); 2282 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCherkEx"); 2283 if (!func_ptr) return GetSymbolNotFoundError(); 2284 return func_ptr(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, 2285 Ctype, ldc); 2286} 2287 2288cublasStatus_t CUBLASWINAPI cublasCherk3mEx( 2289 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2290 int n, int k, const float *alpha, const void *A, cudaDataType Atype, 2291 int lda, const float *beta, void *C, cudaDataType Ctype, int ldc) { 2292 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2293 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2294 const float *, const void *, cudaDataType, int, const float *, void *, 2295 cudaDataType, int); 2296 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCherk3mEx"); 2297 if (!func_ptr) return GetSymbolNotFoundError(); 2298 return func_ptr(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, 2299 Ctype, ldc); 2300} 2301 2302cublasStatus_t CUBLASWINAPI cublasSsyr2k_v2( 2303 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2304 int n, int k, const float *alpha, /* host or device pointer */ 2305 const float *A, int lda, const float *B, int ldb, 2306 const float *beta, /* host or device pointer */ 2307 float *C, int ldc) { 2308 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2309 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2310 const float *, const float *, int, const float *, int, const float *, 2311 float *, int); 2312 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr2k_v2"); 2313 if (!func_ptr) return GetSymbolNotFoundError(); 2314 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2315 ldc); 2316} 2317 2318cublasStatus_t CUBLASWINAPI cublasDsyr2k_v2( 2319 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2320 int n, int k, const double *alpha, /* host or device pointer */ 2321 const double *A, int lda, const double *B, int ldb, 2322 const double *beta, /* host or device pointer */ 2323 double *C, int ldc) { 2324 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2325 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2326 const double *, const double *, int, const double *, int, const double *, 2327 double *, int); 2328 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr2k_v2"); 2329 if (!func_ptr) return GetSymbolNotFoundError(); 2330 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2331 ldc); 2332} 2333 2334cublasStatus_t CUBLASWINAPI cublasCsyr2k_v2( 2335 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2336 int n, int k, const cuComplex *alpha, /* host or device pointer */ 2337 const cuComplex *A, int lda, const cuComplex *B, int ldb, 2338 const cuComplex *beta, /* host or device pointer */ 2339 cuComplex *C, int ldc) { 2340 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2341 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2342 const cuComplex *, const cuComplex *, int, const cuComplex *, int, 2343 const cuComplex *, cuComplex *, int); 2344 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyr2k_v2"); 2345 if (!func_ptr) return GetSymbolNotFoundError(); 2346 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2347 ldc); 2348} 2349 2350cublasStatus_t CUBLASWINAPI cublasZsyr2k_v2( 2351 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2352 int n, int k, const cuDoubleComplex *alpha, /* host or device pointer */ 2353 const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, 2354 const cuDoubleComplex *beta, /* host or device pointer */ 2355 cuDoubleComplex *C, int ldc) { 2356 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2357 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2358 const cuDoubleComplex *, const cuDoubleComplex *, int, 2359 const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *, 2360 int); 2361 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyr2k_v2"); 2362 if (!func_ptr) return GetSymbolNotFoundError(); 2363 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2364 ldc); 2365} 2366 2367cublasStatus_t CUBLASWINAPI cublasCher2k_v2( 2368 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2369 int n, int k, const cuComplex *alpha, /* host or device pointer */ 2370 const cuComplex *A, int lda, const cuComplex *B, int ldb, 2371 const float *beta, /* host or device pointer */ 2372 cuComplex *C, int ldc) { 2373 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2374 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2375 const cuComplex *, const cuComplex *, int, const cuComplex *, int, 2376 const float *, cuComplex *, int); 2377 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher2k_v2"); 2378 if (!func_ptr) return GetSymbolNotFoundError(); 2379 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2380 ldc); 2381} 2382 2383cublasStatus_t CUBLASWINAPI cublasZher2k_v2( 2384 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2385 int n, int k, const cuDoubleComplex *alpha, /* host or device pointer */ 2386 const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, 2387 const double *beta, /* host or device pointer */ 2388 cuDoubleComplex *C, int ldc) { 2389 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2390 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2391 const cuDoubleComplex *, const cuDoubleComplex *, int, 2392 const cuDoubleComplex *, int, const double *, cuDoubleComplex *, int); 2393 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher2k_v2"); 2394 if (!func_ptr) return GetSymbolNotFoundError(); 2395 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2396 ldc); 2397} 2398 2399cublasStatus_t CUBLASWINAPI cublasSsyrkx( 2400 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2401 int n, int k, const float *alpha, /* host or device pointer */ 2402 const float *A, int lda, const float *B, int ldb, 2403 const float *beta, /* host or device pointer */ 2404 float *C, int ldc) { 2405 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2406 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2407 const float *, const float *, int, const float *, int, const float *, 2408 float *, int); 2409 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyrkx"); 2410 if (!func_ptr) return GetSymbolNotFoundError(); 2411 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2412 ldc); 2413} 2414 2415cublasStatus_t CUBLASWINAPI cublasDsyrkx( 2416 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2417 int n, int k, const double *alpha, /* host or device pointer */ 2418 const double *A, int lda, const double *B, int ldb, 2419 const double *beta, /* host or device pointer */ 2420 double *C, int ldc) { 2421 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2422 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2423 const double *, const double *, int, const double *, int, const double *, 2424 double *, int); 2425 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyrkx"); 2426 if (!func_ptr) return GetSymbolNotFoundError(); 2427 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2428 ldc); 2429} 2430 2431cublasStatus_t CUBLASWINAPI cublasCsyrkx( 2432 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2433 int n, int k, const cuComplex *alpha, /* host or device pointer */ 2434 const cuComplex *A, int lda, const cuComplex *B, int ldb, 2435 const cuComplex *beta, /* host or device pointer */ 2436 cuComplex *C, int ldc) { 2437 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2438 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2439 const cuComplex *, const cuComplex *, int, const cuComplex *, int, 2440 const cuComplex *, cuComplex *, int); 2441 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyrkx"); 2442 if (!func_ptr) return GetSymbolNotFoundError(); 2443 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2444 ldc); 2445} 2446 2447cublasStatus_t CUBLASWINAPI cublasZsyrkx( 2448 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2449 int n, int k, const cuDoubleComplex *alpha, /* host or device pointer */ 2450 const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, 2451 const cuDoubleComplex *beta, /* host or device pointer */ 2452 cuDoubleComplex *C, int ldc) { 2453 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2454 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2455 const cuDoubleComplex *, const cuDoubleComplex *, int, 2456 const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *, 2457 int); 2458 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyrkx"); 2459 if (!func_ptr) return GetSymbolNotFoundError(); 2460 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2461 ldc); 2462} 2463 2464cublasStatus_t CUBLASWINAPI cublasCherkx( 2465 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2466 int n, int k, const cuComplex *alpha, /* host or device pointer */ 2467 const cuComplex *A, int lda, const cuComplex *B, int ldb, 2468 const float *beta, /* host or device pointer */ 2469 cuComplex *C, int ldc) { 2470 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2471 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2472 const cuComplex *, const cuComplex *, int, const cuComplex *, int, 2473 const float *, cuComplex *, int); 2474 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCherkx"); 2475 if (!func_ptr) return GetSymbolNotFoundError(); 2476 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2477 ldc); 2478} 2479 2480cublasStatus_t CUBLASWINAPI cublasZherkx( 2481 cublasHandle_t handle, cublasFillMode_t uplo, cublasOperation_t trans, 2482 int n, int k, const cuDoubleComplex *alpha, /* host or device pointer */ 2483 const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, 2484 const double *beta, /* host or device pointer */ 2485 cuDoubleComplex *C, int ldc) { 2486 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2487 cublasHandle_t, cublasFillMode_t, cublasOperation_t, int, int, 2488 const cuDoubleComplex *, const cuDoubleComplex *, int, 2489 const cuDoubleComplex *, int, const double *, cuDoubleComplex *, int); 2490 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZherkx"); 2491 if (!func_ptr) return GetSymbolNotFoundError(); 2492 return func_ptr(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, 2493 ldc); 2494} 2495 2496cublasStatus_t CUBLASWINAPI cublasSsymm_v2( 2497 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m, 2498 int n, const float *alpha, /* host or device pointer */ 2499 const float *A, int lda, const float *B, int ldb, 2500 const float *beta, /* host or device pointer */ 2501 float *C, int ldc) { 2502 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2503 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int, 2504 const float *, const float *, int, const float *, int, const float *, 2505 float *, int); 2506 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsymm_v2"); 2507 if (!func_ptr) return GetSymbolNotFoundError(); 2508 return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, 2509 ldc); 2510} 2511 2512cublasStatus_t CUBLASWINAPI cublasDsymm_v2( 2513 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m, 2514 int n, const double *alpha, /* host or device pointer */ 2515 const double *A, int lda, const double *B, int ldb, 2516 const double *beta, /* host or device pointer */ 2517 double *C, int ldc) { 2518 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2519 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int, 2520 const double *, const double *, int, const double *, int, const double *, 2521 double *, int); 2522 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsymm_v2"); 2523 if (!func_ptr) return GetSymbolNotFoundError(); 2524 return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, 2525 ldc); 2526} 2527 2528cublasStatus_t CUBLASWINAPI cublasCsymm_v2( 2529 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m, 2530 int n, const cuComplex *alpha, /* host or device pointer */ 2531 const cuComplex *A, int lda, const cuComplex *B, int ldb, 2532 const cuComplex *beta, /* host or device pointer */ 2533 cuComplex *C, int ldc) { 2534 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2535 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int, 2536 const cuComplex *, const cuComplex *, int, const cuComplex *, int, 2537 const cuComplex *, cuComplex *, int); 2538 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsymm_v2"); 2539 if (!func_ptr) return GetSymbolNotFoundError(); 2540 return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, 2541 ldc); 2542} 2543 2544cublasStatus_t CUBLASWINAPI cublasZsymm_v2( 2545 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m, 2546 int n, const cuDoubleComplex *alpha, /* host or device pointer */ 2547 const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, 2548 const cuDoubleComplex *beta, /* host or device pointer */ 2549 cuDoubleComplex *C, int ldc) { 2550 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2551 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int, 2552 const cuDoubleComplex *, const cuDoubleComplex *, int, 2553 const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *, 2554 int); 2555 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsymm_v2"); 2556 if (!func_ptr) return GetSymbolNotFoundError(); 2557 return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, 2558 ldc); 2559} 2560 2561cublasStatus_t CUBLASWINAPI cublasChemm_v2( 2562 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m, 2563 int n, const cuComplex *alpha, /* host or device pointer */ 2564 const cuComplex *A, int lda, const cuComplex *B, int ldb, 2565 const cuComplex *beta, /* host or device pointer */ 2566 cuComplex *C, int ldc) { 2567 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2568 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int, 2569 const cuComplex *, const cuComplex *, int, const cuComplex *, int, 2570 const cuComplex *, cuComplex *, int); 2571 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChemm_v2"); 2572 if (!func_ptr) return GetSymbolNotFoundError(); 2573 return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, 2574 ldc); 2575} 2576 2577cublasStatus_t CUBLASWINAPI cublasZhemm_v2( 2578 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, int m, 2579 int n, const cuDoubleComplex *alpha, /* host or device pointer */ 2580 const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, 2581 const cuDoubleComplex *beta, /* host or device pointer */ 2582 cuDoubleComplex *C, int ldc) { 2583 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2584 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, int, int, 2585 const cuDoubleComplex *, const cuDoubleComplex *, int, 2586 const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *, 2587 int); 2588 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhemm_v2"); 2589 if (!func_ptr) return GetSymbolNotFoundError(); 2590 return func_ptr(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, 2591 ldc); 2592} 2593 2594cublasStatus_t CUBLASWINAPI cublasStrsm_v2( 2595 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 2596 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 2597 const float *alpha, /* host or device pointer */ 2598 const float *A, int lda, float *B, int ldb) { 2599 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2600 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 2601 cublasDiagType_t, int, int, const float *, const float *, int, float *, 2602 int); 2603 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrsm_v2"); 2604 if (!func_ptr) return GetSymbolNotFoundError(); 2605 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb); 2606} 2607 2608cublasStatus_t CUBLASWINAPI cublasDtrsm_v2( 2609 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 2610 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 2611 const double *alpha, /* host or device pointer */ 2612 const double *A, int lda, double *B, int ldb) { 2613 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2614 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 2615 cublasDiagType_t, int, int, const double *, const double *, int, double *, 2616 int); 2617 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrsm_v2"); 2618 if (!func_ptr) return GetSymbolNotFoundError(); 2619 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb); 2620} 2621 2622cublasStatus_t CUBLASWINAPI cublasCtrsm_v2( 2623 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 2624 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 2625 const cuComplex *alpha, /* host or device pointer */ 2626 const cuComplex *A, int lda, cuComplex *B, int ldb) { 2627 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2628 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 2629 cublasDiagType_t, int, int, const cuComplex *, const cuComplex *, int, 2630 cuComplex *, int); 2631 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrsm_v2"); 2632 if (!func_ptr) return GetSymbolNotFoundError(); 2633 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb); 2634} 2635 2636cublasStatus_t CUBLASWINAPI cublasZtrsm_v2( 2637 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 2638 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 2639 const cuDoubleComplex *alpha, /* host or device pointer */ 2640 const cuDoubleComplex *A, int lda, cuDoubleComplex *B, int ldb) { 2641 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2642 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 2643 cublasDiagType_t, int, int, const cuDoubleComplex *, 2644 const cuDoubleComplex *, int, cuDoubleComplex *, int); 2645 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrsm_v2"); 2646 if (!func_ptr) return GetSymbolNotFoundError(); 2647 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb); 2648} 2649 2650cublasStatus_t CUBLASWINAPI cublasStrmm_v2( 2651 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 2652 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 2653 const float *alpha, /* host or device pointer */ 2654 const float *A, int lda, const float *B, int ldb, float *C, int ldc) { 2655 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2656 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 2657 cublasDiagType_t, int, int, const float *, const float *, int, 2658 const float *, int, float *, int); 2659 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrmm_v2"); 2660 if (!func_ptr) return GetSymbolNotFoundError(); 2661 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, 2662 C, ldc); 2663} 2664 2665cublasStatus_t CUBLASWINAPI cublasDtrmm_v2( 2666 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 2667 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 2668 const double *alpha, /* host or device pointer */ 2669 const double *A, int lda, const double *B, int ldb, double *C, int ldc) { 2670 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2671 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 2672 cublasDiagType_t, int, int, const double *, const double *, int, 2673 const double *, int, double *, int); 2674 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrmm_v2"); 2675 if (!func_ptr) return GetSymbolNotFoundError(); 2676 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, 2677 C, ldc); 2678} 2679 2680cublasStatus_t CUBLASWINAPI cublasCtrmm_v2( 2681 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 2682 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 2683 const cuComplex *alpha, /* host or device pointer */ 2684 const cuComplex *A, int lda, const cuComplex *B, int ldb, cuComplex *C, 2685 int ldc) { 2686 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2687 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 2688 cublasDiagType_t, int, int, const cuComplex *, const cuComplex *, int, 2689 const cuComplex *, int, cuComplex *, int); 2690 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrmm_v2"); 2691 if (!func_ptr) return GetSymbolNotFoundError(); 2692 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, 2693 C, ldc); 2694} 2695 2696cublasStatus_t CUBLASWINAPI cublasZtrmm_v2( 2697 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 2698 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 2699 const cuDoubleComplex *alpha, /* host or device pointer */ 2700 const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, 2701 cuDoubleComplex *C, int ldc) { 2702 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2703 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 2704 cublasDiagType_t, int, int, const cuDoubleComplex *, 2705 const cuDoubleComplex *, int, const cuDoubleComplex *, int, 2706 cuDoubleComplex *, int); 2707 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrmm_v2"); 2708 if (!func_ptr) return GetSymbolNotFoundError(); 2709 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, 2710 C, ldc); 2711} 2712 2713cublasStatus_t CUBLASWINAPI cublasSgemmBatched( 2714 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2715 int m, int n, int k, const float *alpha, /* host or device pointer */ 2716 const float *const Aarray[], int lda, const float *const Barray[], int ldb, 2717 const float *beta, /* host or device pointer */ 2718 float *const Carray[], int ldc, int batchCount) { 2719 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2720 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2721 const float *, const float *const[], int, const float *const[], int, 2722 const float *, float *const[], int, int); 2723 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemmBatched"); 2724 if (!func_ptr) return GetSymbolNotFoundError(); 2725 return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, lda, Barray, 2726 ldb, beta, Carray, ldc, batchCount); 2727} 2728 2729cublasStatus_t CUBLASWINAPI cublasDgemmBatched( 2730 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2731 int m, int n, int k, const double *alpha, /* host or device pointer */ 2732 const double *const Aarray[], int lda, const double *const Barray[], 2733 int ldb, const double *beta, /* host or device pointer */ 2734 double *const Carray[], int ldc, int batchCount) { 2735 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2736 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2737 const double *, const double *const[], int, const double *const[], int, 2738 const double *, double *const[], int, int); 2739 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemmBatched"); 2740 if (!func_ptr) return GetSymbolNotFoundError(); 2741 return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, lda, Barray, 2742 ldb, beta, Carray, ldc, batchCount); 2743} 2744 2745cublasStatus_t CUBLASWINAPI cublasCgemmBatched( 2746 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2747 int m, int n, int k, const cuComplex *alpha, /* host or device pointer */ 2748 const cuComplex *const Aarray[], int lda, const cuComplex *const Barray[], 2749 int ldb, const cuComplex *beta, /* host or device pointer */ 2750 cuComplex *const Carray[], int ldc, int batchCount) { 2751 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2752 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2753 const cuComplex *, const cuComplex *const[], int, 2754 const cuComplex *const[], int, const cuComplex *, cuComplex *const[], int, 2755 int); 2756 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemmBatched"); 2757 if (!func_ptr) return GetSymbolNotFoundError(); 2758 return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, lda, Barray, 2759 ldb, beta, Carray, ldc, batchCount); 2760} 2761 2762cublasStatus_t CUBLASWINAPI cublasCgemm3mBatched( 2763 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2764 int m, int n, int k, const cuComplex *alpha, /* host or device pointer */ 2765 const cuComplex *const Aarray[], int lda, const cuComplex *const Barray[], 2766 int ldb, const cuComplex *beta, /* host or device pointer */ 2767 cuComplex *const Carray[], int ldc, int batchCount) { 2768 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2769 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2770 const cuComplex *, const cuComplex *const[], int, 2771 const cuComplex *const[], int, const cuComplex *, cuComplex *const[], int, 2772 int); 2773 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm3mBatched"); 2774 if (!func_ptr) return GetSymbolNotFoundError(); 2775 return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, lda, Barray, 2776 ldb, beta, Carray, ldc, batchCount); 2777} 2778 2779cublasStatus_t CUBLASWINAPI 2780cublasZgemmBatched(cublasHandle_t handle, cublasOperation_t transa, 2781 cublasOperation_t transb, int m, int n, int k, 2782 const cuDoubleComplex *alpha, /* host or device pointer */ 2783 const cuDoubleComplex *const Aarray[], int lda, 2784 const cuDoubleComplex *const Barray[], int ldb, 2785 const cuDoubleComplex *beta, /* host or device pointer */ 2786 cuDoubleComplex *const Carray[], int ldc, int batchCount) { 2787 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2788 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2789 const cuDoubleComplex *, const cuDoubleComplex *const[], int, 2790 const cuDoubleComplex *const[], int, const cuDoubleComplex *, 2791 cuDoubleComplex *const[], int, int); 2792 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemmBatched"); 2793 if (!func_ptr) return GetSymbolNotFoundError(); 2794 return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, lda, Barray, 2795 ldb, beta, Carray, ldc, batchCount); 2796} 2797 2798cublasStatus_t CUBLASWINAPI cublasGemmBatchedEx( 2799 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2800 int m, int n, int k, const void *alpha, /* host or device pointer */ 2801 const void *const Aarray[], cudaDataType Atype, int lda, 2802 const void *const Barray[], cudaDataType Btype, int ldb, 2803 const void *beta, /* host or device pointer */ 2804 void *const Carray[], cudaDataType Ctype, int ldc, int batchCount, 2805 cublasComputeType_t computeType, cublasGemmAlgo_t algo) { 2806 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2807 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2808 const void *, const void *const[], cudaDataType, int, const void *const[], 2809 cudaDataType, int, const void *, void *const[], cudaDataType, int, int, 2810 cublasComputeType_t, cublasGemmAlgo_t); 2811 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGemmBatchedEx"); 2812 if (!func_ptr) return GetSymbolNotFoundError(); 2813 return func_ptr(handle, transa, transb, m, n, k, alpha, Aarray, Atype, lda, 2814 Barray, Btype, ldb, beta, Carray, Ctype, ldc, batchCount, 2815 computeType, algo); 2816} 2817 2818cublasStatus_t CUBLASWINAPI cublasGemmStridedBatchedEx( 2819 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2820 int m, int n, int k, const void *alpha, /* host or device pointer */ 2821 const void *A, cudaDataType Atype, int lda, 2822 long long int strideA, /* purposely signed */ 2823 const void *B, cudaDataType Btype, int ldb, long long int strideB, 2824 const void *beta, /* host or device pointer */ 2825 void *C, cudaDataType Ctype, int ldc, long long int strideC, int batchCount, 2826 cublasComputeType_t computeType, cublasGemmAlgo_t algo) { 2827 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2828 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2829 const void *, const void *, cudaDataType, int, long long, const void *, 2830 cudaDataType, int, long long, const void *, void *, cudaDataType, int, 2831 long long, int, cublasComputeType_t, cublasGemmAlgo_t); 2832 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGemmStridedBatchedEx"); 2833 if (!func_ptr) return GetSymbolNotFoundError(); 2834 return func_ptr(handle, transa, transb, m, n, k, alpha, A, Atype, lda, 2835 strideA, B, Btype, ldb, strideB, beta, C, Ctype, ldc, strideC, 2836 batchCount, computeType, algo); 2837} 2838 2839cublasStatus_t CUBLASWINAPI cublasSgemmStridedBatched( 2840 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2841 int m, int n, int k, const float *alpha, /* host or device pointer */ 2842 const float *A, int lda, long long int strideA, /* purposely signed */ 2843 const float *B, int ldb, long long int strideB, 2844 const float *beta, /* host or device pointer */ 2845 float *C, int ldc, long long int strideC, int batchCount) { 2846 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2847 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2848 const float *, const float *, int, long long, const float *, int, 2849 long long, const float *, float *, int, long long, int); 2850 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemmStridedBatched"); 2851 if (!func_ptr) return GetSymbolNotFoundError(); 2852 return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, strideA, B, 2853 ldb, strideB, beta, C, ldc, strideC, batchCount); 2854} 2855 2856cublasStatus_t CUBLASWINAPI cublasDgemmStridedBatched( 2857 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2858 int m, int n, int k, const double *alpha, /* host or device pointer */ 2859 const double *A, int lda, long long int strideA, /* purposely signed */ 2860 const double *B, int ldb, long long int strideB, 2861 const double *beta, /* host or device pointer */ 2862 double *C, int ldc, long long int strideC, int batchCount) { 2863 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2864 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2865 const double *, const double *, int, long long, const double *, int, 2866 long long, const double *, double *, int, long long, int); 2867 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemmStridedBatched"); 2868 if (!func_ptr) return GetSymbolNotFoundError(); 2869 return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, strideA, B, 2870 ldb, strideB, beta, C, ldc, strideC, batchCount); 2871} 2872 2873cublasStatus_t CUBLASWINAPI cublasCgemmStridedBatched( 2874 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2875 int m, int n, int k, const cuComplex *alpha, /* host or device pointer */ 2876 const cuComplex *A, int lda, long long int strideA, /* purposely signed */ 2877 const cuComplex *B, int ldb, long long int strideB, 2878 const cuComplex *beta, /* host or device pointer */ 2879 cuComplex *C, int ldc, long long int strideC, int batchCount) { 2880 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2881 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2882 const cuComplex *, const cuComplex *, int, long long, const cuComplex *, 2883 int, long long, const cuComplex *, cuComplex *, int, long long, int); 2884 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemmStridedBatched"); 2885 if (!func_ptr) return GetSymbolNotFoundError(); 2886 return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, strideA, B, 2887 ldb, strideB, beta, C, ldc, strideC, batchCount); 2888} 2889 2890cublasStatus_t CUBLASWINAPI cublasCgemm3mStridedBatched( 2891 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2892 int m, int n, int k, const cuComplex *alpha, /* host or device pointer */ 2893 const cuComplex *A, int lda, long long int strideA, /* purposely signed */ 2894 const cuComplex *B, int ldb, long long int strideB, 2895 const cuComplex *beta, /* host or device pointer */ 2896 cuComplex *C, int ldc, long long int strideC, int batchCount) { 2897 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2898 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2899 const cuComplex *, const cuComplex *, int, long long, const cuComplex *, 2900 int, long long, const cuComplex *, cuComplex *, int, long long, int); 2901 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm3mStridedBatched"); 2902 if (!func_ptr) return GetSymbolNotFoundError(); 2903 return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, strideA, B, 2904 ldb, strideB, beta, C, ldc, strideC, batchCount); 2905} 2906 2907cublasStatus_t CUBLASWINAPI cublasZgemmStridedBatched( 2908 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2909 int m, int n, int k, 2910 const cuDoubleComplex *alpha, /* host or device pointer */ 2911 const cuDoubleComplex *A, int lda, 2912 long long int strideA, /* purposely signed */ 2913 const cuDoubleComplex *B, int ldb, long long int strideB, 2914 const cuDoubleComplex *beta, /* host or device poi */ 2915 cuDoubleComplex *C, int ldc, long long int strideC, int batchCount) { 2916 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2917 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, int, 2918 const cuDoubleComplex *, const cuDoubleComplex *, int, long long, 2919 const cuDoubleComplex *, int, long long, const cuDoubleComplex *, 2920 cuDoubleComplex *, int, long long, int); 2921 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemmStridedBatched"); 2922 if (!func_ptr) return GetSymbolNotFoundError(); 2923 return func_ptr(handle, transa, transb, m, n, k, alpha, A, lda, strideA, B, 2924 ldb, strideB, beta, C, ldc, strideC, batchCount); 2925} 2926 2927cublasStatus_t CUBLASWINAPI cublasSgeam( 2928 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2929 int m, int n, const float *alpha, /* host or device pointer */ 2930 const float *A, int lda, const float *beta, /* host or device pointer */ 2931 const float *B, int ldb, float *C, int ldc) { 2932 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2933 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, 2934 const float *, const float *, int, const float *, const float *, int, 2935 float *, int); 2936 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgeam"); 2937 if (!func_ptr) return GetSymbolNotFoundError(); 2938 return func_ptr(handle, transa, transb, m, n, alpha, A, lda, beta, B, ldb, C, 2939 ldc); 2940} 2941 2942cublasStatus_t CUBLASWINAPI cublasDgeam( 2943 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2944 int m, int n, const double *alpha, /* host or device pointer */ 2945 const double *A, int lda, const double *beta, /* host or device pointer */ 2946 const double *B, int ldb, double *C, int ldc) { 2947 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2948 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, 2949 const double *, const double *, int, const double *, const double *, int, 2950 double *, int); 2951 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgeam"); 2952 if (!func_ptr) return GetSymbolNotFoundError(); 2953 return func_ptr(handle, transa, transb, m, n, alpha, A, lda, beta, B, ldb, C, 2954 ldc); 2955} 2956 2957cublasStatus_t CUBLASWINAPI cublasCgeam( 2958 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2959 int m, int n, const cuComplex *alpha, /* host or device pointer */ 2960 const cuComplex *A, int lda, 2961 const cuComplex *beta, /* host or device pointer */ 2962 const cuComplex *B, int ldb, cuComplex *C, int ldc) { 2963 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2964 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, 2965 const cuComplex *, const cuComplex *, int, const cuComplex *, 2966 const cuComplex *, int, cuComplex *, int); 2967 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgeam"); 2968 if (!func_ptr) return GetSymbolNotFoundError(); 2969 return func_ptr(handle, transa, transb, m, n, alpha, A, lda, beta, B, ldb, C, 2970 ldc); 2971} 2972 2973cublasStatus_t CUBLASWINAPI cublasZgeam( 2974 cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, 2975 int m, int n, const cuDoubleComplex *alpha, /* host or device pointer */ 2976 const cuDoubleComplex *A, int lda, 2977 const cuDoubleComplex *beta, /* host or device pointer */ 2978 const cuDoubleComplex *B, int ldb, cuDoubleComplex *C, int ldc) { 2979 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2980 cublasHandle_t, cublasOperation_t, cublasOperation_t, int, int, 2981 const cuDoubleComplex *, const cuDoubleComplex *, int, 2982 const cuDoubleComplex *, const cuDoubleComplex *, int, cuDoubleComplex *, 2983 int); 2984 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgeam"); 2985 if (!func_ptr) return GetSymbolNotFoundError(); 2986 return func_ptr(handle, transa, transb, m, n, alpha, A, lda, beta, B, ldb, C, 2987 ldc); 2988} 2989 2990cublasStatus_t CUBLASWINAPI cublasSgetrfBatched( 2991 cublasHandle_t handle, int n, float *const A[], /*Device pointer*/ 2992 int lda, int *P, /*Device Pointer*/ 2993 int *info, /*Device Pointer*/ 2994 int batchSize) { 2995 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 2996 cublasHandle_t, int, float *const[], int, int *, int *, int); 2997 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgetrfBatched"); 2998 if (!func_ptr) return GetSymbolNotFoundError(); 2999 return func_ptr(handle, n, A, lda, P, info, batchSize); 3000} 3001 3002cublasStatus_t CUBLASWINAPI cublasDgetrfBatched( 3003 cublasHandle_t handle, int n, double *const A[], /*Device pointer*/ 3004 int lda, int *P, /*Device Pointer*/ 3005 int *info, /*Device Pointer*/ 3006 int batchSize) { 3007 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3008 cublasHandle_t, int, double *const[], int, int *, int *, int); 3009 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgetrfBatched"); 3010 if (!func_ptr) return GetSymbolNotFoundError(); 3011 return func_ptr(handle, n, A, lda, P, info, batchSize); 3012} 3013 3014cublasStatus_t CUBLASWINAPI cublasCgetrfBatched( 3015 cublasHandle_t handle, int n, cuComplex *const A[], /*Device pointer*/ 3016 int lda, int *P, /*Device Pointer*/ 3017 int *info, /*Device Pointer*/ 3018 int batchSize) { 3019 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3020 cublasHandle_t, int, cuComplex *const[], int, int *, int *, int); 3021 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgetrfBatched"); 3022 if (!func_ptr) return GetSymbolNotFoundError(); 3023 return func_ptr(handle, n, A, lda, P, info, batchSize); 3024} 3025 3026cublasStatus_t CUBLASWINAPI cublasZgetrfBatched( 3027 cublasHandle_t handle, int n, cuDoubleComplex *const A[], /*Device pointer*/ 3028 int lda, int *P, /*Device Pointer*/ 3029 int *info, /*Device Pointer*/ 3030 int batchSize) { 3031 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3032 cublasHandle_t, int, cuDoubleComplex *const[], int, int *, int *, int); 3033 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgetrfBatched"); 3034 if (!func_ptr) return GetSymbolNotFoundError(); 3035 return func_ptr(handle, n, A, lda, P, info, batchSize); 3036} 3037 3038cublasStatus_t CUBLASWINAPI cublasSgetriBatched( 3039 cublasHandle_t handle, int n, const float *const A[], /*Device pointer*/ 3040 int lda, const int *P, /*Device pointer*/ 3041 float *const C[], /*Device pointer*/ 3042 int ldc, int *info, int batchSize) { 3043 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3044 cublasHandle_t, int, const float *const[], int, const int *, 3045 float *const[], int, int *, int); 3046 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgetriBatched"); 3047 if (!func_ptr) return GetSymbolNotFoundError(); 3048 return func_ptr(handle, n, A, lda, P, C, ldc, info, batchSize); 3049} 3050 3051cublasStatus_t CUBLASWINAPI cublasDgetriBatched( 3052 cublasHandle_t handle, int n, const double *const A[], /*Device pointer*/ 3053 int lda, const int *P, /*Device pointer*/ 3054 double *const C[], /*Device pointer*/ 3055 int ldc, int *info, int batchSize) { 3056 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3057 cublasHandle_t, int, const double *const[], int, const int *, 3058 double *const[], int, int *, int); 3059 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgetriBatched"); 3060 if (!func_ptr) return GetSymbolNotFoundError(); 3061 return func_ptr(handle, n, A, lda, P, C, ldc, info, batchSize); 3062} 3063 3064cublasStatus_t CUBLASWINAPI cublasCgetriBatched( 3065 cublasHandle_t handle, int n, const cuComplex *const A[], /*Device pointer*/ 3066 int lda, const int *P, /*Device pointer*/ 3067 cuComplex *const C[], /*Device pointer*/ 3068 int ldc, int *info, int batchSize) { 3069 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3070 cublasHandle_t, int, const cuComplex *const[], int, const int *, 3071 cuComplex *const[], int, int *, int); 3072 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgetriBatched"); 3073 if (!func_ptr) return GetSymbolNotFoundError(); 3074 return func_ptr(handle, n, A, lda, P, C, ldc, info, batchSize); 3075} 3076 3077cublasStatus_t CUBLASWINAPI 3078cublasZgetriBatched(cublasHandle_t handle, int n, 3079 const cuDoubleComplex *const A[], /*Device pointer*/ 3080 int lda, const int *P, /*Device pointer*/ 3081 cuDoubleComplex *const C[], /*Device pointer*/ 3082 int ldc, int *info, int batchSize) { 3083 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3084 cublasHandle_t, int, const cuDoubleComplex *const[], int, const int *, 3085 cuDoubleComplex *const[], int, int *, int); 3086 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgetriBatched"); 3087 if (!func_ptr) return GetSymbolNotFoundError(); 3088 return func_ptr(handle, n, A, lda, P, C, ldc, info, batchSize); 3089} 3090 3091cublasStatus_t CUBLASWINAPI cublasSgetrsBatched( 3092 cublasHandle_t handle, cublasOperation_t trans, int n, int nrhs, 3093 const float *const Aarray[], int lda, const int *devIpiv, 3094 float *const Barray[], int ldb, int *info, int batchSize) { 3095 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3096 cublasHandle_t, cublasOperation_t, int, int, const float *const[], int, 3097 const int *, float *const[], int, int *, int); 3098 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgetrsBatched"); 3099 if (!func_ptr) return GetSymbolNotFoundError(); 3100 return func_ptr(handle, trans, n, nrhs, Aarray, lda, devIpiv, Barray, ldb, 3101 info, batchSize); 3102} 3103 3104cublasStatus_t CUBLASWINAPI cublasDgetrsBatched( 3105 cublasHandle_t handle, cublasOperation_t trans, int n, int nrhs, 3106 const double *const Aarray[], int lda, const int *devIpiv, 3107 double *const Barray[], int ldb, int *info, int batchSize) { 3108 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3109 cublasHandle_t, cublasOperation_t, int, int, const double *const[], int, 3110 const int *, double *const[], int, int *, int); 3111 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgetrsBatched"); 3112 if (!func_ptr) return GetSymbolNotFoundError(); 3113 return func_ptr(handle, trans, n, nrhs, Aarray, lda, devIpiv, Barray, ldb, 3114 info, batchSize); 3115} 3116 3117cublasStatus_t CUBLASWINAPI cublasCgetrsBatched( 3118 cublasHandle_t handle, cublasOperation_t trans, int n, int nrhs, 3119 const cuComplex *const Aarray[], int lda, const int *devIpiv, 3120 cuComplex *const Barray[], int ldb, int *info, int batchSize) { 3121 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3122 cublasHandle_t, cublasOperation_t, int, int, const cuComplex *const[], 3123 int, const int *, cuComplex *const[], int, int *, int); 3124 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgetrsBatched"); 3125 if (!func_ptr) return GetSymbolNotFoundError(); 3126 return func_ptr(handle, trans, n, nrhs, Aarray, lda, devIpiv, Barray, ldb, 3127 info, batchSize); 3128} 3129 3130cublasStatus_t CUBLASWINAPI cublasZgetrsBatched( 3131 cublasHandle_t handle, cublasOperation_t trans, int n, int nrhs, 3132 const cuDoubleComplex *const Aarray[], int lda, const int *devIpiv, 3133 cuDoubleComplex *const Barray[], int ldb, int *info, int batchSize) { 3134 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3135 cublasHandle_t, cublasOperation_t, int, int, 3136 const cuDoubleComplex *const[], int, const int *, 3137 cuDoubleComplex *const[], int, int *, int); 3138 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgetrsBatched"); 3139 if (!func_ptr) return GetSymbolNotFoundError(); 3140 return func_ptr(handle, trans, n, nrhs, Aarray, lda, devIpiv, Barray, ldb, 3141 info, batchSize); 3142} 3143 3144cublasStatus_t CUBLASWINAPI cublasStrsmBatched( 3145 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 3146 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 3147 const float *alpha, /*Host or Device Pointer*/ 3148 const float *const A[], int lda, float *const B[], int ldb, 3149 int batchCount) { 3150 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3151 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 3152 cublasDiagType_t, int, int, const float *, const float *const[], int, 3153 float *const[], int, int); 3154 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrsmBatched"); 3155 if (!func_ptr) return GetSymbolNotFoundError(); 3156 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, 3157 batchCount); 3158} 3159 3160cublasStatus_t CUBLASWINAPI cublasDtrsmBatched( 3161 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 3162 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 3163 const double *alpha, /*Host or Device Pointer*/ 3164 const double *const A[], int lda, double *const B[], int ldb, 3165 int batchCount) { 3166 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3167 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 3168 cublasDiagType_t, int, int, const double *, const double *const[], int, 3169 double *const[], int, int); 3170 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrsmBatched"); 3171 if (!func_ptr) return GetSymbolNotFoundError(); 3172 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, 3173 batchCount); 3174} 3175 3176cublasStatus_t CUBLASWINAPI cublasCtrsmBatched( 3177 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 3178 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 3179 const cuComplex *alpha, /*Host or Device Pointer*/ 3180 const cuComplex *const A[], int lda, cuComplex *const B[], int ldb, 3181 int batchCount) { 3182 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3183 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 3184 cublasDiagType_t, int, int, const cuComplex *, const cuComplex *const[], 3185 int, cuComplex *const[], int, int); 3186 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrsmBatched"); 3187 if (!func_ptr) return GetSymbolNotFoundError(); 3188 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, 3189 batchCount); 3190} 3191 3192cublasStatus_t CUBLASWINAPI cublasZtrsmBatched( 3193 cublasHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo, 3194 cublasOperation_t trans, cublasDiagType_t diag, int m, int n, 3195 const cuDoubleComplex *alpha, /*Host or Device Pointer*/ 3196 const cuDoubleComplex *const A[], int lda, cuDoubleComplex *const B[], 3197 int ldb, int batchCount) { 3198 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3199 cublasHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t, 3200 cublasDiagType_t, int, int, const cuDoubleComplex *, 3201 const cuDoubleComplex *const[], int, cuDoubleComplex *const[], int, int); 3202 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrsmBatched"); 3203 if (!func_ptr) return GetSymbolNotFoundError(); 3204 return func_ptr(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, 3205 batchCount); 3206} 3207 3208cublasStatus_t CUBLASWINAPI cublasSmatinvBatched( 3209 cublasHandle_t handle, int n, const float *const A[], /*Device pointer*/ 3210 int lda, float *const Ainv[], /*Device pointer*/ 3211 int lda_inv, int *info, /*Device Pointer*/ 3212 int batchSize) { 3213 using FuncPtr = 3214 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, const float *const[], 3215 int, float *const[], int, int *, int); 3216 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSmatinvBatched"); 3217 if (!func_ptr) return GetSymbolNotFoundError(); 3218 return func_ptr(handle, n, A, lda, Ainv, lda_inv, info, batchSize); 3219} 3220 3221cublasStatus_t CUBLASWINAPI cublasDmatinvBatched( 3222 cublasHandle_t handle, int n, const double *const A[], /*Device pointer*/ 3223 int lda, double *const Ainv[], /*Device pointer*/ 3224 int lda_inv, int *info, /*Device Pointer*/ 3225 int batchSize) { 3226 using FuncPtr = 3227 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, const double *const[], 3228 int, double *const[], int, int *, int); 3229 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDmatinvBatched"); 3230 if (!func_ptr) return GetSymbolNotFoundError(); 3231 return func_ptr(handle, n, A, lda, Ainv, lda_inv, info, batchSize); 3232} 3233 3234cublasStatus_t CUBLASWINAPI cublasCmatinvBatched( 3235 cublasHandle_t handle, int n, const cuComplex *const A[], /*Device pointer*/ 3236 int lda, cuComplex *const Ainv[], /*Device pointer*/ 3237 int lda_inv, int *info, /*Device Pointer*/ 3238 int batchSize) { 3239 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3240 cublasHandle_t, int, const cuComplex *const[], int, cuComplex *const[], 3241 int, int *, int); 3242 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCmatinvBatched"); 3243 if (!func_ptr) return GetSymbolNotFoundError(); 3244 return func_ptr(handle, n, A, lda, Ainv, lda_inv, info, batchSize); 3245} 3246 3247cublasStatus_t CUBLASWINAPI 3248cublasZmatinvBatched(cublasHandle_t handle, int n, 3249 const cuDoubleComplex *const A[], /*Device pointer*/ 3250 int lda, cuDoubleComplex *const Ainv[], /*Device pointer*/ 3251 int lda_inv, int *info, /*Device Pointer*/ 3252 int batchSize) { 3253 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3254 cublasHandle_t, int, const cuDoubleComplex *const[], int, 3255 cuDoubleComplex *const[], int, int *, int); 3256 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZmatinvBatched"); 3257 if (!func_ptr) return GetSymbolNotFoundError(); 3258 return func_ptr(handle, n, A, lda, Ainv, lda_inv, info, batchSize); 3259} 3260 3261cublasStatus_t CUBLASWINAPI 3262cublasSgeqrfBatched(cublasHandle_t handle, int m, int n, 3263 float *const Aarray[], /*Device pointer*/ 3264 int lda, float *const TauArray[], /*Device pointer*/ 3265 int *info, int batchSize) { 3266 using FuncPtr = 3267 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, int, float *const[], 3268 int, float *const[], int *, int); 3269 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgeqrfBatched"); 3270 if (!func_ptr) return GetSymbolNotFoundError(); 3271 return func_ptr(handle, m, n, Aarray, lda, TauArray, info, batchSize); 3272} 3273 3274cublasStatus_t CUBLASWINAPI 3275cublasDgeqrfBatched(cublasHandle_t handle, int m, int n, 3276 double *const Aarray[], /*Device pointer*/ 3277 int lda, double *const TauArray[], /*Device pointer*/ 3278 int *info, int batchSize) { 3279 using FuncPtr = 3280 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, int, int, double *const[], 3281 int, double *const[], int *, int); 3282 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgeqrfBatched"); 3283 if (!func_ptr) return GetSymbolNotFoundError(); 3284 return func_ptr(handle, m, n, Aarray, lda, TauArray, info, batchSize); 3285} 3286 3287cublasStatus_t CUBLASWINAPI 3288cublasCgeqrfBatched(cublasHandle_t handle, int m, int n, 3289 cuComplex *const Aarray[], /*Device pointer*/ 3290 int lda, cuComplex *const TauArray[], /*Device pointer*/ 3291 int *info, int batchSize) { 3292 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3293 cublasHandle_t, int, int, cuComplex *const[], int, cuComplex *const[], 3294 int *, int); 3295 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgeqrfBatched"); 3296 if (!func_ptr) return GetSymbolNotFoundError(); 3297 return func_ptr(handle, m, n, Aarray, lda, TauArray, info, batchSize); 3298} 3299 3300cublasStatus_t CUBLASWINAPI cublasZgeqrfBatched( 3301 cublasHandle_t handle, int m, int n, 3302 cuDoubleComplex *const Aarray[], /*Device pointer*/ 3303 int lda, cuDoubleComplex *const TauArray[], /*Device pointer*/ 3304 int *info, int batchSize) { 3305 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3306 cublasHandle_t, int, int, cuDoubleComplex *const[], int, 3307 cuDoubleComplex *const[], int *, int); 3308 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgeqrfBatched"); 3309 if (!func_ptr) return GetSymbolNotFoundError(); 3310 return func_ptr(handle, m, n, Aarray, lda, TauArray, info, batchSize); 3311} 3312 3313cublasStatus_t CUBLASWINAPI 3314cublasSgelsBatched(cublasHandle_t handle, cublasOperation_t trans, int m, int n, 3315 int nrhs, float *const Aarray[], /*Device pointer*/ 3316 int lda, float *const Carray[], /*Device pointer*/ 3317 int ldc, int *info, int *devInfoArray, /*Device pointer*/ 3318 int batchSize) { 3319 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3320 cublasHandle_t, cublasOperation_t, int, int, int, float *const[], int, 3321 float *const[], int, int *, int *, int); 3322 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgelsBatched"); 3323 if (!func_ptr) return GetSymbolNotFoundError(); 3324 return func_ptr(handle, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info, 3325 devInfoArray, batchSize); 3326} 3327 3328cublasStatus_t CUBLASWINAPI 3329cublasDgelsBatched(cublasHandle_t handle, cublasOperation_t trans, int m, int n, 3330 int nrhs, double *const Aarray[], /*Device pointer*/ 3331 int lda, double *const Carray[], /*Device pointer*/ 3332 int ldc, int *info, int *devInfoArray, /*Device pointer*/ 3333 int batchSize) { 3334 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3335 cublasHandle_t, cublasOperation_t, int, int, int, double *const[], int, 3336 double *const[], int, int *, int *, int); 3337 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgelsBatched"); 3338 if (!func_ptr) return GetSymbolNotFoundError(); 3339 return func_ptr(handle, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info, 3340 devInfoArray, batchSize); 3341} 3342 3343cublasStatus_t CUBLASWINAPI 3344cublasCgelsBatched(cublasHandle_t handle, cublasOperation_t trans, int m, int n, 3345 int nrhs, cuComplex *const Aarray[], /*Device pointer*/ 3346 int lda, cuComplex *const Carray[], /*Device pointer*/ 3347 int ldc, int *info, int *devInfoArray, int batchSize) { 3348 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3349 cublasHandle_t, cublasOperation_t, int, int, int, cuComplex *const[], int, 3350 cuComplex *const[], int, int *, int *, int); 3351 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgelsBatched"); 3352 if (!func_ptr) return GetSymbolNotFoundError(); 3353 return func_ptr(handle, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info, 3354 devInfoArray, batchSize); 3355} 3356 3357cublasStatus_t CUBLASWINAPI 3358cublasZgelsBatched(cublasHandle_t handle, cublasOperation_t trans, int m, int n, 3359 int nrhs, cuDoubleComplex *const Aarray[], /*Device pointer*/ 3360 int lda, cuDoubleComplex *const Carray[], /*Device pointer*/ 3361 int ldc, int *info, int *devInfoArray, int batchSize) { 3362 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3363 cublasHandle_t, cublasOperation_t, int, int, int, 3364 cuDoubleComplex *const[], int, cuDoubleComplex *const[], int, int *, 3365 int *, int); 3366 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgelsBatched"); 3367 if (!func_ptr) return GetSymbolNotFoundError(); 3368 return func_ptr(handle, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info, 3369 devInfoArray, batchSize); 3370} 3371 3372cublasStatus_t CUBLASWINAPI cublasSdgmm(cublasHandle_t handle, 3373 cublasSideMode_t mode, int m, int n, 3374 const float *A, int lda, const float *x, 3375 int incx, float *C, int ldc) { 3376 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3377 cublasHandle_t, cublasSideMode_t, int, int, const float *, int, 3378 const float *, int, float *, int); 3379 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSdgmm"); 3380 if (!func_ptr) return GetSymbolNotFoundError(); 3381 return func_ptr(handle, mode, m, n, A, lda, x, incx, C, ldc); 3382} 3383 3384cublasStatus_t CUBLASWINAPI cublasDdgmm(cublasHandle_t handle, 3385 cublasSideMode_t mode, int m, int n, 3386 const double *A, int lda, 3387 const double *x, int incx, double *C, 3388 int ldc) { 3389 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3390 cublasHandle_t, cublasSideMode_t, int, int, const double *, int, 3391 const double *, int, double *, int); 3392 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDdgmm"); 3393 if (!func_ptr) return GetSymbolNotFoundError(); 3394 return func_ptr(handle, mode, m, n, A, lda, x, incx, C, ldc); 3395} 3396 3397cublasStatus_t CUBLASWINAPI cublasCdgmm(cublasHandle_t handle, 3398 cublasSideMode_t mode, int m, int n, 3399 const cuComplex *A, int lda, 3400 const cuComplex *x, int incx, 3401 cuComplex *C, int ldc) { 3402 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3403 cublasHandle_t, cublasSideMode_t, int, int, const cuComplex *, int, 3404 const cuComplex *, int, cuComplex *, int); 3405 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCdgmm"); 3406 if (!func_ptr) return GetSymbolNotFoundError(); 3407 return func_ptr(handle, mode, m, n, A, lda, x, incx, C, ldc); 3408} 3409 3410cublasStatus_t CUBLASWINAPI cublasZdgmm(cublasHandle_t handle, 3411 cublasSideMode_t mode, int m, int n, 3412 const cuDoubleComplex *A, int lda, 3413 const cuDoubleComplex *x, int incx, 3414 cuDoubleComplex *C, int ldc) { 3415 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3416 cublasHandle_t, cublasSideMode_t, int, int, const cuDoubleComplex *, int, 3417 const cuDoubleComplex *, int, cuDoubleComplex *, int); 3418 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdgmm"); 3419 if (!func_ptr) return GetSymbolNotFoundError(); 3420 return func_ptr(handle, mode, m, n, A, lda, x, incx, C, ldc); 3421} 3422 3423cublasStatus_t CUBLASWINAPI cublasStpttr(cublasHandle_t handle, 3424 cublasFillMode_t uplo, int n, 3425 const float *AP, float *A, int lda) { 3426 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3427 cublasHandle_t, cublasFillMode_t, int, const float *, float *, int); 3428 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStpttr"); 3429 if (!func_ptr) return GetSymbolNotFoundError(); 3430 return func_ptr(handle, uplo, n, AP, A, lda); 3431} 3432 3433cublasStatus_t CUBLASWINAPI cublasDtpttr(cublasHandle_t handle, 3434 cublasFillMode_t uplo, int n, 3435 const double *AP, double *A, int lda) { 3436 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3437 cublasHandle_t, cublasFillMode_t, int, const double *, double *, int); 3438 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtpttr"); 3439 if (!func_ptr) return GetSymbolNotFoundError(); 3440 return func_ptr(handle, uplo, n, AP, A, lda); 3441} 3442 3443cublasStatus_t CUBLASWINAPI cublasCtpttr(cublasHandle_t handle, 3444 cublasFillMode_t uplo, int n, 3445 const cuComplex *AP, cuComplex *A, 3446 int lda) { 3447 using FuncPtr = 3448 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasFillMode_t, int, 3449 const cuComplex *, cuComplex *, int); 3450 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtpttr"); 3451 if (!func_ptr) return GetSymbolNotFoundError(); 3452 return func_ptr(handle, uplo, n, AP, A, lda); 3453} 3454 3455cublasStatus_t CUBLASWINAPI cublasZtpttr(cublasHandle_t handle, 3456 cublasFillMode_t uplo, int n, 3457 const cuDoubleComplex *AP, 3458 cuDoubleComplex *A, int lda) { 3459 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3460 cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, 3461 cuDoubleComplex *, int); 3462 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtpttr"); 3463 if (!func_ptr) return GetSymbolNotFoundError(); 3464 return func_ptr(handle, uplo, n, AP, A, lda); 3465} 3466 3467cublasStatus_t CUBLASWINAPI cublasStrttp(cublasHandle_t handle, 3468 cublasFillMode_t uplo, int n, 3469 const float *A, int lda, float *AP) { 3470 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3471 cublasHandle_t, cublasFillMode_t, int, const float *, int, float *); 3472 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrttp"); 3473 if (!func_ptr) return GetSymbolNotFoundError(); 3474 return func_ptr(handle, uplo, n, A, lda, AP); 3475} 3476 3477cublasStatus_t CUBLASWINAPI cublasDtrttp(cublasHandle_t handle, 3478 cublasFillMode_t uplo, int n, 3479 const double *A, int lda, double *AP) { 3480 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3481 cublasHandle_t, cublasFillMode_t, int, const double *, int, double *); 3482 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrttp"); 3483 if (!func_ptr) return GetSymbolNotFoundError(); 3484 return func_ptr(handle, uplo, n, A, lda, AP); 3485} 3486 3487cublasStatus_t CUBLASWINAPI cublasCtrttp(cublasHandle_t handle, 3488 cublasFillMode_t uplo, int n, 3489 const cuComplex *A, int lda, 3490 cuComplex *AP) { 3491 using FuncPtr = 3492 cublasStatus_t(CUBLASWINAPI *)(cublasHandle_t, cublasFillMode_t, int, 3493 const cuComplex *, int, cuComplex *); 3494 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrttp"); 3495 if (!func_ptr) return GetSymbolNotFoundError(); 3496 return func_ptr(handle, uplo, n, A, lda, AP); 3497} 3498 3499cublasStatus_t CUBLASWINAPI cublasZtrttp(cublasHandle_t handle, 3500 cublasFillMode_t uplo, int n, 3501 const cuDoubleComplex *A, int lda, 3502 cuDoubleComplex *AP) { 3503 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)( 3504 cublasHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, int, 3505 cuDoubleComplex *); 3506 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrttp"); 3507 if (!func_ptr) return GetSymbolNotFoundError(); 3508 return func_ptr(handle, uplo, n, A, lda, AP); 3509} 3510 3511cublasStatus CUBLASWINAPI cublasInit(void) { 3512 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(); 3513 static auto func_ptr = LoadSymbol<FuncPtr>("cublasInit"); 3514 if (!func_ptr) return GetSymbolNotFoundError(); 3515 return func_ptr(); 3516} 3517 3518cublasStatus CUBLASWINAPI cublasShutdown(void) { 3519 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(); 3520 static auto func_ptr = LoadSymbol<FuncPtr>("cublasShutdown"); 3521 if (!func_ptr) return GetSymbolNotFoundError(); 3522 return func_ptr(); 3523} 3524 3525cublasStatus CUBLASWINAPI cublasGetError(void) { 3526 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(); 3527 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetError"); 3528 if (!func_ptr) return GetSymbolNotFoundError(); 3529 return func_ptr(); 3530} 3531 3532cublasStatus CUBLASWINAPI cublasGetVersion(int *version) { 3533 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int *); 3534 static auto func_ptr = LoadSymbol<FuncPtr>("cublasGetVersion"); 3535 if (!func_ptr) return GetSymbolNotFoundError(); 3536 return func_ptr(version); 3537} 3538 3539cublasStatus CUBLASWINAPI cublasAlloc(int n, int elemSize, void **devicePtr) { 3540 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(int, int, void **); 3541 static auto func_ptr = LoadSymbol<FuncPtr>("cublasAlloc"); 3542 if (!func_ptr) return GetSymbolNotFoundError(); 3543 return func_ptr(n, elemSize, devicePtr); 3544} 3545 3546cublasStatus CUBLASWINAPI cublasFree(void *devicePtr) { 3547 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(void *); 3548 static auto func_ptr = LoadSymbol<FuncPtr>("cublasFree"); 3549 if (!func_ptr) return GetSymbolNotFoundError(); 3550 return func_ptr(devicePtr); 3551} 3552 3553cublasStatus CUBLASWINAPI cublasSetKernelStream(cudaStream_t stream) { 3554 using FuncPtr = cublasStatus_t(CUBLASWINAPI *)(cudaStream_t); 3555 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSetKernelStream"); 3556 if (!func_ptr) return GetSymbolNotFoundError(); 3557 return func_ptr(stream); 3558} 3559 3560float CUBLASWINAPI cublasSnrm2(int n, const float *x, int incx) { 3561 using FuncPtr = float(CUBLASWINAPI *)(int, const float *, int); 3562 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSnrm2"); 3563 if (!func_ptr) LogFatalSymbolNotFound("cublasSnrm2"); 3564 return func_ptr(n, x, incx); 3565} 3566 3567double CUBLASWINAPI cublasDnrm2(int n, const double *x, int incx) { 3568 using FuncPtr = double(CUBLASWINAPI *)(int, const double *, int); 3569 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDnrm2"); 3570 if (!func_ptr) LogFatalSymbolNotFound("cublasDnrm2"); 3571 return func_ptr(n, x, incx); 3572} 3573 3574float CUBLASWINAPI cublasScnrm2(int n, const cuComplex *x, int incx) { 3575 using FuncPtr = float(CUBLASWINAPI *)(int, const cuComplex *, int); 3576 static auto func_ptr = LoadSymbol<FuncPtr>("cublasScnrm2"); 3577 if (!func_ptr) LogFatalSymbolNotFound("cublasScnrm2"); 3578 return func_ptr(n, x, incx); 3579} 3580 3581double CUBLASWINAPI cublasDznrm2(int n, const cuDoubleComplex *x, int incx) { 3582 using FuncPtr = double(CUBLASWINAPI *)(int, const cuDoubleComplex *, int); 3583 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDznrm2"); 3584 if (!func_ptr) LogFatalSymbolNotFound("cublasDznrm2"); 3585 return func_ptr(n, x, incx); 3586} 3587 3588float CUBLASWINAPI cublasSdot(int n, const float *x, int incx, const float *y, 3589 int incy) { 3590 using FuncPtr = 3591 float(CUBLASWINAPI *)(int, const float *, int, const float *, int); 3592 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSdot"); 3593 if (!func_ptr) LogFatalSymbolNotFound("cublasSdot"); 3594 return func_ptr(n, x, incx, y, incy); 3595} 3596 3597double CUBLASWINAPI cublasDdot(int n, const double *x, int incx, 3598 const double *y, int incy) { 3599 using FuncPtr = 3600 double(CUBLASWINAPI *)(int, const double *, int, const double *, int); 3601 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDdot"); 3602 if (!func_ptr) LogFatalSymbolNotFound("cublasDdot"); 3603 return func_ptr(n, x, incx, y, incy); 3604} 3605 3606cuComplex CUBLASWINAPI cublasCdotu(int n, const cuComplex *x, int incx, 3607 const cuComplex *y, int incy) { 3608 using FuncPtr = cuComplex(CUBLASWINAPI *)(int, const cuComplex *, int, 3609 const cuComplex *, int); 3610 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCdotu"); 3611 if (!func_ptr) LogFatalSymbolNotFound("cublasCdotu"); 3612 return func_ptr(n, x, incx, y, incy); 3613} 3614 3615cuComplex CUBLASWINAPI cublasCdotc(int n, const cuComplex *x, int incx, 3616 const cuComplex *y, int incy) { 3617 using FuncPtr = cuComplex(CUBLASWINAPI *)(int, const cuComplex *, int, 3618 const cuComplex *, int); 3619 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCdotc"); 3620 if (!func_ptr) LogFatalSymbolNotFound("cublasCdotc"); 3621 return func_ptr(n, x, incx, y, incy); 3622} 3623 3624cuDoubleComplex CUBLASWINAPI cublasZdotu(int n, const cuDoubleComplex *x, 3625 int incx, const cuDoubleComplex *y, 3626 int incy) { 3627 using FuncPtr = cuDoubleComplex(CUBLASWINAPI *)( 3628 int, const cuDoubleComplex *, int, const cuDoubleComplex *, int); 3629 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdotu"); 3630 if (!func_ptr) LogFatalSymbolNotFound("cublasZdotu"); 3631 return func_ptr(n, x, incx, y, incy); 3632} 3633 3634cuDoubleComplex CUBLASWINAPI cublasZdotc(int n, const cuDoubleComplex *x, 3635 int incx, const cuDoubleComplex *y, 3636 int incy) { 3637 using FuncPtr = cuDoubleComplex(CUBLASWINAPI *)( 3638 int, const cuDoubleComplex *, int, const cuDoubleComplex *, int); 3639 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdotc"); 3640 if (!func_ptr) LogFatalSymbolNotFound("cublasZdotc"); 3641 return func_ptr(n, x, incx, y, incy); 3642} 3643 3644void CUBLASWINAPI cublasSscal(int n, float alpha, float *x, int incx) { 3645 using FuncPtr = void(CUBLASWINAPI *)(int, float, float *, int); 3646 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSscal"); 3647 if (!func_ptr) LogFatalSymbolNotFound("cublasSscal"); 3648 return func_ptr(n, alpha, x, incx); 3649} 3650 3651void CUBLASWINAPI cublasDscal(int n, double alpha, double *x, int incx) { 3652 using FuncPtr = void(CUBLASWINAPI *)(int, double, double *, int); 3653 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDscal"); 3654 if (!func_ptr) LogFatalSymbolNotFound("cublasDscal"); 3655 return func_ptr(n, alpha, x, incx); 3656} 3657 3658void CUBLASWINAPI cublasCscal(int n, cuComplex alpha, cuComplex *x, int incx) { 3659 using FuncPtr = void(CUBLASWINAPI *)(int, cuComplex, cuComplex *, int); 3660 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCscal"); 3661 if (!func_ptr) LogFatalSymbolNotFound("cublasCscal"); 3662 return func_ptr(n, alpha, x, incx); 3663} 3664 3665void CUBLASWINAPI cublasZscal(int n, cuDoubleComplex alpha, cuDoubleComplex *x, 3666 int incx) { 3667 using FuncPtr = 3668 void(CUBLASWINAPI *)(int, cuDoubleComplex, cuDoubleComplex *, int); 3669 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZscal"); 3670 if (!func_ptr) LogFatalSymbolNotFound("cublasZscal"); 3671 return func_ptr(n, alpha, x, incx); 3672} 3673 3674void CUBLASWINAPI cublasCsscal(int n, float alpha, cuComplex *x, int incx) { 3675 using FuncPtr = void(CUBLASWINAPI *)(int, float, cuComplex *, int); 3676 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsscal"); 3677 if (!func_ptr) LogFatalSymbolNotFound("cublasCsscal"); 3678 return func_ptr(n, alpha, x, incx); 3679} 3680 3681void CUBLASWINAPI cublasZdscal(int n, double alpha, cuDoubleComplex *x, 3682 int incx) { 3683 using FuncPtr = void(CUBLASWINAPI *)(int, double, cuDoubleComplex *, int); 3684 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdscal"); 3685 if (!func_ptr) LogFatalSymbolNotFound("cublasZdscal"); 3686 return func_ptr(n, alpha, x, incx); 3687} 3688 3689void CUBLASWINAPI cublasSaxpy(int n, float alpha, const float *x, int incx, 3690 float *y, int incy) { 3691 using FuncPtr = 3692 void(CUBLASWINAPI *)(int, float, const float *, int, float *, int); 3693 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSaxpy"); 3694 if (!func_ptr) LogFatalSymbolNotFound("cublasSaxpy"); 3695 return func_ptr(n, alpha, x, incx, y, incy); 3696} 3697 3698void CUBLASWINAPI cublasDaxpy(int n, double alpha, const double *x, int incx, 3699 double *y, int incy) { 3700 using FuncPtr = 3701 void(CUBLASWINAPI *)(int, double, const double *, int, double *, int); 3702 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDaxpy"); 3703 if (!func_ptr) LogFatalSymbolNotFound("cublasDaxpy"); 3704 return func_ptr(n, alpha, x, incx, y, incy); 3705} 3706 3707void CUBLASWINAPI cublasCaxpy(int n, cuComplex alpha, const cuComplex *x, 3708 int incx, cuComplex *y, int incy) { 3709 using FuncPtr = void(CUBLASWINAPI *)(int, cuComplex, const cuComplex *, int, 3710 cuComplex *, int); 3711 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCaxpy"); 3712 if (!func_ptr) LogFatalSymbolNotFound("cublasCaxpy"); 3713 return func_ptr(n, alpha, x, incx, y, incy); 3714} 3715 3716void CUBLASWINAPI cublasZaxpy(int n, cuDoubleComplex alpha, 3717 const cuDoubleComplex *x, int incx, 3718 cuDoubleComplex *y, int incy) { 3719 using FuncPtr = 3720 void(CUBLASWINAPI *)(int, cuDoubleComplex, const cuDoubleComplex *, int, 3721 cuDoubleComplex *, int); 3722 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZaxpy"); 3723 if (!func_ptr) LogFatalSymbolNotFound("cublasZaxpy"); 3724 return func_ptr(n, alpha, x, incx, y, incy); 3725} 3726 3727void CUBLASWINAPI cublasScopy(int n, const float *x, int incx, float *y, 3728 int incy) { 3729 using FuncPtr = void(CUBLASWINAPI *)(int, const float *, int, float *, int); 3730 static auto func_ptr = LoadSymbol<FuncPtr>("cublasScopy"); 3731 if (!func_ptr) LogFatalSymbolNotFound("cublasScopy"); 3732 return func_ptr(n, x, incx, y, incy); 3733} 3734 3735void CUBLASWINAPI cublasDcopy(int n, const double *x, int incx, double *y, 3736 int incy) { 3737 using FuncPtr = void(CUBLASWINAPI *)(int, const double *, int, double *, int); 3738 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDcopy"); 3739 if (!func_ptr) LogFatalSymbolNotFound("cublasDcopy"); 3740 return func_ptr(n, x, incx, y, incy); 3741} 3742 3743void CUBLASWINAPI cublasCcopy(int n, const cuComplex *x, int incx, cuComplex *y, 3744 int incy) { 3745 using FuncPtr = 3746 void(CUBLASWINAPI *)(int, const cuComplex *, int, cuComplex *, int); 3747 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCcopy"); 3748 if (!func_ptr) LogFatalSymbolNotFound("cublasCcopy"); 3749 return func_ptr(n, x, incx, y, incy); 3750} 3751 3752void CUBLASWINAPI cublasZcopy(int n, const cuDoubleComplex *x, int incx, 3753 cuDoubleComplex *y, int incy) { 3754 using FuncPtr = void(CUBLASWINAPI *)(int, const cuDoubleComplex *, int, 3755 cuDoubleComplex *, int); 3756 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZcopy"); 3757 if (!func_ptr) LogFatalSymbolNotFound("cublasZcopy"); 3758 return func_ptr(n, x, incx, y, incy); 3759} 3760 3761void CUBLASWINAPI cublasSswap(int n, float *x, int incx, float *y, int incy) { 3762 using FuncPtr = void(CUBLASWINAPI *)(int, float *, int, float *, int); 3763 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSswap"); 3764 if (!func_ptr) LogFatalSymbolNotFound("cublasSswap"); 3765 return func_ptr(n, x, incx, y, incy); 3766} 3767 3768void CUBLASWINAPI cublasDswap(int n, double *x, int incx, double *y, int incy) { 3769 using FuncPtr = void(CUBLASWINAPI *)(int, double *, int, double *, int); 3770 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDswap"); 3771 if (!func_ptr) LogFatalSymbolNotFound("cublasDswap"); 3772 return func_ptr(n, x, incx, y, incy); 3773} 3774 3775void CUBLASWINAPI cublasCswap(int n, cuComplex *x, int incx, cuComplex *y, 3776 int incy) { 3777 using FuncPtr = void(CUBLASWINAPI *)(int, cuComplex *, int, cuComplex *, int); 3778 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCswap"); 3779 if (!func_ptr) LogFatalSymbolNotFound("cublasCswap"); 3780 return func_ptr(n, x, incx, y, incy); 3781} 3782 3783void CUBLASWINAPI cublasZswap(int n, cuDoubleComplex *x, int incx, 3784 cuDoubleComplex *y, int incy) { 3785 using FuncPtr = 3786 void(CUBLASWINAPI *)(int, cuDoubleComplex *, int, cuDoubleComplex *, int); 3787 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZswap"); 3788 if (!func_ptr) LogFatalSymbolNotFound("cublasZswap"); 3789 return func_ptr(n, x, incx, y, incy); 3790} 3791 3792int CUBLASWINAPI cublasIsamax(int n, const float *x, int incx) { 3793 using FuncPtr = int(CUBLASWINAPI *)(int, const float *, int); 3794 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIsamax"); 3795 if (!func_ptr) LogFatalSymbolNotFound("cublasIsamax"); 3796 return func_ptr(n, x, incx); 3797} 3798 3799int CUBLASWINAPI cublasIdamax(int n, const double *x, int incx) { 3800 using FuncPtr = int(CUBLASWINAPI *)(int, const double *, int); 3801 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIdamax"); 3802 if (!func_ptr) LogFatalSymbolNotFound("cublasIdamax"); 3803 return func_ptr(n, x, incx); 3804} 3805 3806int CUBLASWINAPI cublasIcamax(int n, const cuComplex *x, int incx) { 3807 using FuncPtr = int(CUBLASWINAPI *)(int, const cuComplex *, int); 3808 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIcamax"); 3809 if (!func_ptr) LogFatalSymbolNotFound("cublasIcamax"); 3810 return func_ptr(n, x, incx); 3811} 3812 3813int CUBLASWINAPI cublasIzamax(int n, const cuDoubleComplex *x, int incx) { 3814 using FuncPtr = int(CUBLASWINAPI *)(int, const cuDoubleComplex *, int); 3815 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIzamax"); 3816 if (!func_ptr) LogFatalSymbolNotFound("cublasIzamax"); 3817 return func_ptr(n, x, incx); 3818} 3819 3820int CUBLASWINAPI cublasIsamin(int n, const float *x, int incx) { 3821 using FuncPtr = int(CUBLASWINAPI *)(int, const float *, int); 3822 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIsamin"); 3823 if (!func_ptr) LogFatalSymbolNotFound("cublasIsamin"); 3824 return func_ptr(n, x, incx); 3825} 3826 3827int CUBLASWINAPI cublasIdamin(int n, const double *x, int incx) { 3828 using FuncPtr = int(CUBLASWINAPI *)(int, const double *, int); 3829 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIdamin"); 3830 if (!func_ptr) LogFatalSymbolNotFound("cublasIdamin"); 3831 return func_ptr(n, x, incx); 3832} 3833 3834int CUBLASWINAPI cublasIcamin(int n, const cuComplex *x, int incx) { 3835 using FuncPtr = int(CUBLASWINAPI *)(int, const cuComplex *, int); 3836 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIcamin"); 3837 if (!func_ptr) LogFatalSymbolNotFound("cublasIcamin"); 3838 return func_ptr(n, x, incx); 3839} 3840 3841int CUBLASWINAPI cublasIzamin(int n, const cuDoubleComplex *x, int incx) { 3842 using FuncPtr = int(CUBLASWINAPI *)(int, const cuDoubleComplex *, int); 3843 static auto func_ptr = LoadSymbol<FuncPtr>("cublasIzamin"); 3844 if (!func_ptr) LogFatalSymbolNotFound("cublasIzamin"); 3845 return func_ptr(n, x, incx); 3846} 3847 3848float CUBLASWINAPI cublasSasum(int n, const float *x, int incx) { 3849 using FuncPtr = float(CUBLASWINAPI *)(int, const float *, int); 3850 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSasum"); 3851 if (!func_ptr) LogFatalSymbolNotFound("cublasSasum"); 3852 return func_ptr(n, x, incx); 3853} 3854 3855double CUBLASWINAPI cublasDasum(int n, const double *x, int incx) { 3856 using FuncPtr = double(CUBLASWINAPI *)(int, const double *, int); 3857 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDasum"); 3858 if (!func_ptr) LogFatalSymbolNotFound("cublasDasum"); 3859 return func_ptr(n, x, incx); 3860} 3861 3862float CUBLASWINAPI cublasScasum(int n, const cuComplex *x, int incx) { 3863 using FuncPtr = float(CUBLASWINAPI *)(int, const cuComplex *, int); 3864 static auto func_ptr = LoadSymbol<FuncPtr>("cublasScasum"); 3865 if (!func_ptr) LogFatalSymbolNotFound("cublasScasum"); 3866 return func_ptr(n, x, incx); 3867} 3868 3869double CUBLASWINAPI cublasDzasum(int n, const cuDoubleComplex *x, int incx) { 3870 using FuncPtr = double(CUBLASWINAPI *)(int, const cuDoubleComplex *, int); 3871 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDzasum"); 3872 if (!func_ptr) LogFatalSymbolNotFound("cublasDzasum"); 3873 return func_ptr(n, x, incx); 3874} 3875 3876void CUBLASWINAPI cublasSrot(int n, float *x, int incx, float *y, int incy, 3877 float sc, float ss) { 3878 using FuncPtr = 3879 void(CUBLASWINAPI *)(int, float *, int, float *, int, float, float); 3880 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrot"); 3881 if (!func_ptr) LogFatalSymbolNotFound("cublasSrot"); 3882 return func_ptr(n, x, incx, y, incy, sc, ss); 3883} 3884 3885void CUBLASWINAPI cublasDrot(int n, double *x, int incx, double *y, int incy, 3886 double sc, double ss) { 3887 using FuncPtr = 3888 void(CUBLASWINAPI *)(int, double *, int, double *, int, double, double); 3889 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrot"); 3890 if (!func_ptr) LogFatalSymbolNotFound("cublasDrot"); 3891 return func_ptr(n, x, incx, y, incy, sc, ss); 3892} 3893 3894void CUBLASWINAPI cublasCrot(int n, cuComplex *x, int incx, cuComplex *y, 3895 int incy, float c, cuComplex s) { 3896 using FuncPtr = void(CUBLASWINAPI *)(int, cuComplex *, int, cuComplex *, int, 3897 float, cuComplex); 3898 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCrot"); 3899 if (!func_ptr) LogFatalSymbolNotFound("cublasCrot"); 3900 return func_ptr(n, x, incx, y, incy, c, s); 3901} 3902 3903void CUBLASWINAPI cublasZrot(int n, cuDoubleComplex *x, int incx, 3904 cuDoubleComplex *y, int incy, double sc, 3905 cuDoubleComplex cs) { 3906 using FuncPtr = 3907 void(CUBLASWINAPI *)(int, cuDoubleComplex *, int, cuDoubleComplex *, int, 3908 double, cuDoubleComplex); 3909 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZrot"); 3910 if (!func_ptr) LogFatalSymbolNotFound("cublasZrot"); 3911 return func_ptr(n, x, incx, y, incy, sc, cs); 3912} 3913 3914void CUBLASWINAPI cublasCsrot(int n, cuComplex *x, int incx, cuComplex *y, 3915 int incy, float c, float s) { 3916 using FuncPtr = void(CUBLASWINAPI *)(int, cuComplex *, int, cuComplex *, int, 3917 float, float); 3918 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsrot"); 3919 if (!func_ptr) LogFatalSymbolNotFound("cublasCsrot"); 3920 return func_ptr(n, x, incx, y, incy, c, s); 3921} 3922 3923void CUBLASWINAPI cublasZdrot(int n, cuDoubleComplex *x, int incx, 3924 cuDoubleComplex *y, int incy, double c, 3925 double s) { 3926 using FuncPtr = void(CUBLASWINAPI *)(int, cuDoubleComplex *, int, 3927 cuDoubleComplex *, int, double, double); 3928 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZdrot"); 3929 if (!func_ptr) LogFatalSymbolNotFound("cublasZdrot"); 3930 return func_ptr(n, x, incx, y, incy, c, s); 3931} 3932 3933void CUBLASWINAPI cublasSrotg(float *sa, float *sb, float *sc, float *ss) { 3934 using FuncPtr = void(CUBLASWINAPI *)(float *, float *, float *, float *); 3935 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotg"); 3936 if (!func_ptr) LogFatalSymbolNotFound("cublasSrotg"); 3937 return func_ptr(sa, sb, sc, ss); 3938} 3939 3940void CUBLASWINAPI cublasDrotg(double *sa, double *sb, double *sc, double *ss) { 3941 using FuncPtr = void(CUBLASWINAPI *)(double *, double *, double *, double *); 3942 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotg"); 3943 if (!func_ptr) LogFatalSymbolNotFound("cublasDrotg"); 3944 return func_ptr(sa, sb, sc, ss); 3945} 3946 3947void CUBLASWINAPI cublasCrotg(cuComplex *ca, cuComplex cb, float *sc, 3948 cuComplex *cs) { 3949 using FuncPtr = 3950 void(CUBLASWINAPI *)(cuComplex *, cuComplex, float *, cuComplex *); 3951 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCrotg"); 3952 if (!func_ptr) LogFatalSymbolNotFound("cublasCrotg"); 3953 return func_ptr(ca, cb, sc, cs); 3954} 3955 3956void CUBLASWINAPI cublasZrotg(cuDoubleComplex *ca, cuDoubleComplex cb, 3957 double *sc, cuDoubleComplex *cs) { 3958 using FuncPtr = void(CUBLASWINAPI *)(cuDoubleComplex *, cuDoubleComplex, 3959 double *, cuDoubleComplex *); 3960 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZrotg"); 3961 if (!func_ptr) LogFatalSymbolNotFound("cublasZrotg"); 3962 return func_ptr(ca, cb, sc, cs); 3963} 3964 3965void CUBLASWINAPI cublasSrotm(int n, float *x, int incx, float *y, int incy, 3966 const float *sparam) { 3967 using FuncPtr = 3968 void(CUBLASWINAPI *)(int, float *, int, float *, int, const float *); 3969 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotm"); 3970 if (!func_ptr) LogFatalSymbolNotFound("cublasSrotm"); 3971 return func_ptr(n, x, incx, y, incy, sparam); 3972} 3973 3974void CUBLASWINAPI cublasDrotm(int n, double *x, int incx, double *y, int incy, 3975 const double *sparam) { 3976 using FuncPtr = 3977 void(CUBLASWINAPI *)(int, double *, int, double *, int, const double *); 3978 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotm"); 3979 if (!func_ptr) LogFatalSymbolNotFound("cublasDrotm"); 3980 return func_ptr(n, x, incx, y, incy, sparam); 3981} 3982 3983void CUBLASWINAPI cublasSrotmg(float *sd1, float *sd2, float *sx1, 3984 const float *sy1, float *sparam) { 3985 using FuncPtr = 3986 void(CUBLASWINAPI *)(float *, float *, float *, const float *, float *); 3987 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSrotmg"); 3988 if (!func_ptr) LogFatalSymbolNotFound("cublasSrotmg"); 3989 return func_ptr(sd1, sd2, sx1, sy1, sparam); 3990} 3991 3992void CUBLASWINAPI cublasDrotmg(double *sd1, double *sd2, double *sx1, 3993 const double *sy1, double *sparam) { 3994 using FuncPtr = void(CUBLASWINAPI *)(double *, double *, double *, 3995 const double *, double *); 3996 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDrotmg"); 3997 if (!func_ptr) LogFatalSymbolNotFound("cublasDrotmg"); 3998 return func_ptr(sd1, sd2, sx1, sy1, sparam); 3999} 4000 4001void CUBLASWINAPI cublasSgemv(char trans, int m, int n, float alpha, 4002 const float *A, int lda, const float *x, int incx, 4003 float beta, float *y, int incy) { 4004 using FuncPtr = 4005 void(CUBLASWINAPI *)(char, int, int, float, const float *, int, 4006 const float *, int, float, float *, int); 4007 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemv"); 4008 if (!func_ptr) LogFatalSymbolNotFound("cublasSgemv"); 4009 return func_ptr(trans, m, n, alpha, A, lda, x, incx, beta, y, incy); 4010} 4011 4012void CUBLASWINAPI cublasDgemv(char trans, int m, int n, double alpha, 4013 const double *A, int lda, const double *x, 4014 int incx, double beta, double *y, int incy) { 4015 using FuncPtr = 4016 void(CUBLASWINAPI *)(char, int, int, double, const double *, int, 4017 const double *, int, double, double *, int); 4018 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemv"); 4019 if (!func_ptr) LogFatalSymbolNotFound("cublasDgemv"); 4020 return func_ptr(trans, m, n, alpha, A, lda, x, incx, beta, y, incy); 4021} 4022 4023void CUBLASWINAPI cublasCgemv(char trans, int m, int n, cuComplex alpha, 4024 const cuComplex *A, int lda, const cuComplex *x, 4025 int incx, cuComplex beta, cuComplex *y, 4026 int incy) { 4027 using FuncPtr = 4028 void(CUBLASWINAPI *)(char, int, int, cuComplex, const cuComplex *, int, 4029 const cuComplex *, int, cuComplex, cuComplex *, int); 4030 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemv"); 4031 if (!func_ptr) LogFatalSymbolNotFound("cublasCgemv"); 4032 return func_ptr(trans, m, n, alpha, A, lda, x, incx, beta, y, incy); 4033} 4034 4035void CUBLASWINAPI cublasZgemv(char trans, int m, int n, cuDoubleComplex alpha, 4036 const cuDoubleComplex *A, int lda, 4037 const cuDoubleComplex *x, int incx, 4038 cuDoubleComplex beta, cuDoubleComplex *y, 4039 int incy) { 4040 using FuncPtr = void(CUBLASWINAPI *)( 4041 char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, 4042 const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int); 4043 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemv"); 4044 if (!func_ptr) LogFatalSymbolNotFound("cublasZgemv"); 4045 return func_ptr(trans, m, n, alpha, A, lda, x, incx, beta, y, incy); 4046} 4047 4048void CUBLASWINAPI cublasSgbmv(char trans, int m, int n, int kl, int ku, 4049 float alpha, const float *A, int lda, 4050 const float *x, int incx, float beta, float *y, 4051 int incy) { 4052 using FuncPtr = 4053 void(CUBLASWINAPI *)(char, int, int, int, int, float, const float *, int, 4054 const float *, int, float, float *, int); 4055 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgbmv"); 4056 if (!func_ptr) LogFatalSymbolNotFound("cublasSgbmv"); 4057 return func_ptr(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy); 4058} 4059 4060void CUBLASWINAPI cublasDgbmv(char trans, int m, int n, int kl, int ku, 4061 double alpha, const double *A, int lda, 4062 const double *x, int incx, double beta, double *y, 4063 int incy) { 4064 using FuncPtr = 4065 void(CUBLASWINAPI *)(char, int, int, int, int, double, const double *, 4066 int, const double *, int, double, double *, int); 4067 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgbmv"); 4068 if (!func_ptr) LogFatalSymbolNotFound("cublasDgbmv"); 4069 return func_ptr(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy); 4070} 4071 4072void CUBLASWINAPI cublasCgbmv(char trans, int m, int n, int kl, int ku, 4073 cuComplex alpha, const cuComplex *A, int lda, 4074 const cuComplex *x, int incx, cuComplex beta, 4075 cuComplex *y, int incy) { 4076 using FuncPtr = void(CUBLASWINAPI *)( 4077 char, int, int, int, int, cuComplex, const cuComplex *, int, 4078 const cuComplex *, int, cuComplex, cuComplex *, int); 4079 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgbmv"); 4080 if (!func_ptr) LogFatalSymbolNotFound("cublasCgbmv"); 4081 return func_ptr(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy); 4082} 4083 4084void CUBLASWINAPI cublasZgbmv(char trans, int m, int n, int kl, int ku, 4085 cuDoubleComplex alpha, const cuDoubleComplex *A, 4086 int lda, const cuDoubleComplex *x, int incx, 4087 cuDoubleComplex beta, cuDoubleComplex *y, 4088 int incy) { 4089 using FuncPtr = void(CUBLASWINAPI *)( 4090 char, int, int, int, int, cuDoubleComplex, const cuDoubleComplex *, int, 4091 const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int); 4092 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgbmv"); 4093 if (!func_ptr) LogFatalSymbolNotFound("cublasZgbmv"); 4094 return func_ptr(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy); 4095} 4096 4097void CUBLASWINAPI cublasStrmv(char uplo, char trans, char diag, int n, 4098 const float *A, int lda, float *x, int incx) { 4099 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const float *, 4100 int, float *, int); 4101 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrmv"); 4102 if (!func_ptr) LogFatalSymbolNotFound("cublasStrmv"); 4103 return func_ptr(uplo, trans, diag, n, A, lda, x, incx); 4104} 4105 4106void CUBLASWINAPI cublasDtrmv(char uplo, char trans, char diag, int n, 4107 const double *A, int lda, double *x, int incx) { 4108 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const double *, 4109 int, double *, int); 4110 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrmv"); 4111 if (!func_ptr) LogFatalSymbolNotFound("cublasDtrmv"); 4112 return func_ptr(uplo, trans, diag, n, A, lda, x, incx); 4113} 4114 4115void CUBLASWINAPI cublasCtrmv(char uplo, char trans, char diag, int n, 4116 const cuComplex *A, int lda, cuComplex *x, 4117 int incx) { 4118 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const cuComplex *, 4119 int, cuComplex *, int); 4120 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrmv"); 4121 if (!func_ptr) LogFatalSymbolNotFound("cublasCtrmv"); 4122 return func_ptr(uplo, trans, diag, n, A, lda, x, incx); 4123} 4124 4125void CUBLASWINAPI cublasZtrmv(char uplo, char trans, char diag, int n, 4126 const cuDoubleComplex *A, int lda, 4127 cuDoubleComplex *x, int incx) { 4128 using FuncPtr = 4129 void(CUBLASWINAPI *)(char, char, char, int, const cuDoubleComplex *, int, 4130 cuDoubleComplex *, int); 4131 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrmv"); 4132 if (!func_ptr) LogFatalSymbolNotFound("cublasZtrmv"); 4133 return func_ptr(uplo, trans, diag, n, A, lda, x, incx); 4134} 4135 4136void CUBLASWINAPI cublasStbmv(char uplo, char trans, char diag, int n, int k, 4137 const float *A, int lda, float *x, int incx) { 4138 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, int, 4139 const float *, int, float *, int); 4140 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStbmv"); 4141 if (!func_ptr) LogFatalSymbolNotFound("cublasStbmv"); 4142 return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx); 4143} 4144 4145void CUBLASWINAPI cublasDtbmv(char uplo, char trans, char diag, int n, int k, 4146 const double *A, int lda, double *x, int incx) { 4147 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, int, 4148 const double *, int, double *, int); 4149 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtbmv"); 4150 if (!func_ptr) LogFatalSymbolNotFound("cublasDtbmv"); 4151 return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx); 4152} 4153 4154void CUBLASWINAPI cublasCtbmv(char uplo, char trans, char diag, int n, int k, 4155 const cuComplex *A, int lda, cuComplex *x, 4156 int incx) { 4157 using FuncPtr = void(CUBLASWINAPI *)( 4158 char, char, char, int, int, const cuComplex *, int, cuComplex *, int); 4159 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtbmv"); 4160 if (!func_ptr) LogFatalSymbolNotFound("cublasCtbmv"); 4161 return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx); 4162} 4163 4164void CUBLASWINAPI cublasZtbmv(char uplo, char trans, char diag, int n, int k, 4165 const cuDoubleComplex *A, int lda, 4166 cuDoubleComplex *x, int incx) { 4167 using FuncPtr = 4168 void(CUBLASWINAPI *)(char, char, char, int, int, const cuDoubleComplex *, 4169 int, cuDoubleComplex *, int); 4170 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtbmv"); 4171 if (!func_ptr) LogFatalSymbolNotFound("cublasZtbmv"); 4172 return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx); 4173} 4174 4175void CUBLASWINAPI cublasStpmv(char uplo, char trans, char diag, int n, 4176 const float *AP, float *x, int incx) { 4177 using FuncPtr = 4178 void(CUBLASWINAPI *)(char, char, char, int, const float *, float *, int); 4179 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStpmv"); 4180 if (!func_ptr) LogFatalSymbolNotFound("cublasStpmv"); 4181 return func_ptr(uplo, trans, diag, n, AP, x, incx); 4182} 4183 4184void CUBLASWINAPI cublasDtpmv(char uplo, char trans, char diag, int n, 4185 const double *AP, double *x, int incx) { 4186 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const double *, 4187 double *, int); 4188 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtpmv"); 4189 if (!func_ptr) LogFatalSymbolNotFound("cublasDtpmv"); 4190 return func_ptr(uplo, trans, diag, n, AP, x, incx); 4191} 4192 4193void CUBLASWINAPI cublasCtpmv(char uplo, char trans, char diag, int n, 4194 const cuComplex *AP, cuComplex *x, int incx) { 4195 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const cuComplex *, 4196 cuComplex *, int); 4197 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtpmv"); 4198 if (!func_ptr) LogFatalSymbolNotFound("cublasCtpmv"); 4199 return func_ptr(uplo, trans, diag, n, AP, x, incx); 4200} 4201 4202void CUBLASWINAPI cublasZtpmv(char uplo, char trans, char diag, int n, 4203 const cuDoubleComplex *AP, cuDoubleComplex *x, 4204 int incx) { 4205 using FuncPtr = void(CUBLASWINAPI *)( 4206 char, char, char, int, const cuDoubleComplex *, cuDoubleComplex *, int); 4207 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtpmv"); 4208 if (!func_ptr) LogFatalSymbolNotFound("cublasZtpmv"); 4209 return func_ptr(uplo, trans, diag, n, AP, x, incx); 4210} 4211 4212void CUBLASWINAPI cublasStrsv(char uplo, char trans, char diag, int n, 4213 const float *A, int lda, float *x, int incx) { 4214 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const float *, 4215 int, float *, int); 4216 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrsv"); 4217 if (!func_ptr) LogFatalSymbolNotFound("cublasStrsv"); 4218 return func_ptr(uplo, trans, diag, n, A, lda, x, incx); 4219} 4220 4221void CUBLASWINAPI cublasDtrsv(char uplo, char trans, char diag, int n, 4222 const double *A, int lda, double *x, int incx) { 4223 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const double *, 4224 int, double *, int); 4225 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrsv"); 4226 if (!func_ptr) LogFatalSymbolNotFound("cublasDtrsv"); 4227 return func_ptr(uplo, trans, diag, n, A, lda, x, incx); 4228} 4229 4230void CUBLASWINAPI cublasCtrsv(char uplo, char trans, char diag, int n, 4231 const cuComplex *A, int lda, cuComplex *x, 4232 int incx) { 4233 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const cuComplex *, 4234 int, cuComplex *, int); 4235 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrsv"); 4236 if (!func_ptr) LogFatalSymbolNotFound("cublasCtrsv"); 4237 return func_ptr(uplo, trans, diag, n, A, lda, x, incx); 4238} 4239 4240void CUBLASWINAPI cublasZtrsv(char uplo, char trans, char diag, int n, 4241 const cuDoubleComplex *A, int lda, 4242 cuDoubleComplex *x, int incx) { 4243 using FuncPtr = 4244 void(CUBLASWINAPI *)(char, char, char, int, const cuDoubleComplex *, int, 4245 cuDoubleComplex *, int); 4246 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrsv"); 4247 if (!func_ptr) LogFatalSymbolNotFound("cublasZtrsv"); 4248 return func_ptr(uplo, trans, diag, n, A, lda, x, incx); 4249} 4250 4251void CUBLASWINAPI cublasStpsv(char uplo, char trans, char diag, int n, 4252 const float *AP, float *x, int incx) { 4253 using FuncPtr = 4254 void(CUBLASWINAPI *)(char, char, char, int, const float *, float *, int); 4255 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStpsv"); 4256 if (!func_ptr) LogFatalSymbolNotFound("cublasStpsv"); 4257 return func_ptr(uplo, trans, diag, n, AP, x, incx); 4258} 4259 4260void CUBLASWINAPI cublasDtpsv(char uplo, char trans, char diag, int n, 4261 const double *AP, double *x, int incx) { 4262 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const double *, 4263 double *, int); 4264 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtpsv"); 4265 if (!func_ptr) LogFatalSymbolNotFound("cublasDtpsv"); 4266 return func_ptr(uplo, trans, diag, n, AP, x, incx); 4267} 4268 4269void CUBLASWINAPI cublasCtpsv(char uplo, char trans, char diag, int n, 4270 const cuComplex *AP, cuComplex *x, int incx) { 4271 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, const cuComplex *, 4272 cuComplex *, int); 4273 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtpsv"); 4274 if (!func_ptr) LogFatalSymbolNotFound("cublasCtpsv"); 4275 return func_ptr(uplo, trans, diag, n, AP, x, incx); 4276} 4277 4278void CUBLASWINAPI cublasZtpsv(char uplo, char trans, char diag, int n, 4279 const cuDoubleComplex *AP, cuDoubleComplex *x, 4280 int incx) { 4281 using FuncPtr = void(CUBLASWINAPI *)( 4282 char, char, char, int, const cuDoubleComplex *, cuDoubleComplex *, int); 4283 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtpsv"); 4284 if (!func_ptr) LogFatalSymbolNotFound("cublasZtpsv"); 4285 return func_ptr(uplo, trans, diag, n, AP, x, incx); 4286} 4287 4288void CUBLASWINAPI cublasStbsv(char uplo, char trans, char diag, int n, int k, 4289 const float *A, int lda, float *x, int incx) { 4290 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, int, 4291 const float *, int, float *, int); 4292 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStbsv"); 4293 if (!func_ptr) LogFatalSymbolNotFound("cublasStbsv"); 4294 return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx); 4295} 4296 4297void CUBLASWINAPI cublasDtbsv(char uplo, char trans, char diag, int n, int k, 4298 const double *A, int lda, double *x, int incx) { 4299 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, int, int, 4300 const double *, int, double *, int); 4301 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtbsv"); 4302 if (!func_ptr) LogFatalSymbolNotFound("cublasDtbsv"); 4303 return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx); 4304} 4305 4306void CUBLASWINAPI cublasCtbsv(char uplo, char trans, char diag, int n, int k, 4307 const cuComplex *A, int lda, cuComplex *x, 4308 int incx) { 4309 using FuncPtr = void(CUBLASWINAPI *)( 4310 char, char, char, int, int, const cuComplex *, int, cuComplex *, int); 4311 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtbsv"); 4312 if (!func_ptr) LogFatalSymbolNotFound("cublasCtbsv"); 4313 return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx); 4314} 4315 4316void CUBLASWINAPI cublasZtbsv(char uplo, char trans, char diag, int n, int k, 4317 const cuDoubleComplex *A, int lda, 4318 cuDoubleComplex *x, int incx) { 4319 using FuncPtr = 4320 void(CUBLASWINAPI *)(char, char, char, int, int, const cuDoubleComplex *, 4321 int, cuDoubleComplex *, int); 4322 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtbsv"); 4323 if (!func_ptr) LogFatalSymbolNotFound("cublasZtbsv"); 4324 return func_ptr(uplo, trans, diag, n, k, A, lda, x, incx); 4325} 4326 4327void CUBLASWINAPI cublasSsymv(char uplo, int n, float alpha, const float *A, 4328 int lda, const float *x, int incx, float beta, 4329 float *y, int incy) { 4330 using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const float *, int, 4331 const float *, int, float, float *, int); 4332 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsymv"); 4333 if (!func_ptr) LogFatalSymbolNotFound("cublasSsymv"); 4334 return func_ptr(uplo, n, alpha, A, lda, x, incx, beta, y, incy); 4335} 4336 4337void CUBLASWINAPI cublasDsymv(char uplo, int n, double alpha, const double *A, 4338 int lda, const double *x, int incx, double beta, 4339 double *y, int incy) { 4340 using FuncPtr = 4341 void(CUBLASWINAPI *)(char, int, double, const double *, int, 4342 const double *, int, double, double *, int); 4343 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsymv"); 4344 if (!func_ptr) LogFatalSymbolNotFound("cublasDsymv"); 4345 return func_ptr(uplo, n, alpha, A, lda, x, incx, beta, y, incy); 4346} 4347 4348void CUBLASWINAPI cublasChemv(char uplo, int n, cuComplex alpha, 4349 const cuComplex *A, int lda, const cuComplex *x, 4350 int incx, cuComplex beta, cuComplex *y, 4351 int incy) { 4352 using FuncPtr = 4353 void(CUBLASWINAPI *)(char, int, cuComplex, const cuComplex *, int, 4354 const cuComplex *, int, cuComplex, cuComplex *, int); 4355 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChemv"); 4356 if (!func_ptr) LogFatalSymbolNotFound("cublasChemv"); 4357 return func_ptr(uplo, n, alpha, A, lda, x, incx, beta, y, incy); 4358} 4359 4360void CUBLASWINAPI cublasZhemv(char uplo, int n, cuDoubleComplex alpha, 4361 const cuDoubleComplex *A, int lda, 4362 const cuDoubleComplex *x, int incx, 4363 cuDoubleComplex beta, cuDoubleComplex *y, 4364 int incy) { 4365 using FuncPtr = void(CUBLASWINAPI *)( 4366 char, int, cuDoubleComplex, const cuDoubleComplex *, int, 4367 const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int); 4368 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhemv"); 4369 if (!func_ptr) LogFatalSymbolNotFound("cublasZhemv"); 4370 return func_ptr(uplo, n, alpha, A, lda, x, incx, beta, y, incy); 4371} 4372 4373void CUBLASWINAPI cublasSsbmv(char uplo, int n, int k, float alpha, 4374 const float *A, int lda, const float *x, int incx, 4375 float beta, float *y, int incy) { 4376 using FuncPtr = 4377 void(CUBLASWINAPI *)(char, int, int, float, const float *, int, 4378 const float *, int, float, float *, int); 4379 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsbmv"); 4380 if (!func_ptr) LogFatalSymbolNotFound("cublasSsbmv"); 4381 return func_ptr(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy); 4382} 4383 4384void CUBLASWINAPI cublasDsbmv(char uplo, int n, int k, double alpha, 4385 const double *A, int lda, const double *x, 4386 int incx, double beta, double *y, int incy) { 4387 using FuncPtr = 4388 void(CUBLASWINAPI *)(char, int, int, double, const double *, int, 4389 const double *, int, double, double *, int); 4390 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsbmv"); 4391 if (!func_ptr) LogFatalSymbolNotFound("cublasDsbmv"); 4392 return func_ptr(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy); 4393} 4394 4395void CUBLASWINAPI cublasChbmv(char uplo, int n, int k, cuComplex alpha, 4396 const cuComplex *A, int lda, const cuComplex *x, 4397 int incx, cuComplex beta, cuComplex *y, 4398 int incy) { 4399 using FuncPtr = 4400 void(CUBLASWINAPI *)(char, int, int, cuComplex, const cuComplex *, int, 4401 const cuComplex *, int, cuComplex, cuComplex *, int); 4402 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChbmv"); 4403 if (!func_ptr) LogFatalSymbolNotFound("cublasChbmv"); 4404 return func_ptr(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy); 4405} 4406 4407void CUBLASWINAPI cublasZhbmv(char uplo, int n, int k, cuDoubleComplex alpha, 4408 const cuDoubleComplex *A, int lda, 4409 const cuDoubleComplex *x, int incx, 4410 cuDoubleComplex beta, cuDoubleComplex *y, 4411 int incy) { 4412 using FuncPtr = void(CUBLASWINAPI *)( 4413 char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, 4414 const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int); 4415 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhbmv"); 4416 if (!func_ptr) LogFatalSymbolNotFound("cublasZhbmv"); 4417 return func_ptr(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy); 4418} 4419 4420void CUBLASWINAPI cublasSspmv(char uplo, int n, float alpha, const float *AP, 4421 const float *x, int incx, float beta, float *y, 4422 int incy) { 4423 using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const float *, 4424 const float *, int, float, float *, int); 4425 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspmv"); 4426 if (!func_ptr) LogFatalSymbolNotFound("cublasSspmv"); 4427 return func_ptr(uplo, n, alpha, AP, x, incx, beta, y, incy); 4428} 4429 4430void CUBLASWINAPI cublasDspmv(char uplo, int n, double alpha, const double *AP, 4431 const double *x, int incx, double beta, double *y, 4432 int incy) { 4433 using FuncPtr = 4434 void(CUBLASWINAPI *)(char, int, double, const double *, const double *, 4435 int, double, double *, int); 4436 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspmv"); 4437 if (!func_ptr) LogFatalSymbolNotFound("cublasDspmv"); 4438 return func_ptr(uplo, n, alpha, AP, x, incx, beta, y, incy); 4439} 4440 4441void CUBLASWINAPI cublasChpmv(char uplo, int n, cuComplex alpha, 4442 const cuComplex *AP, const cuComplex *x, int incx, 4443 cuComplex beta, cuComplex *y, int incy) { 4444 using FuncPtr = 4445 void(CUBLASWINAPI *)(char, int, cuComplex, const cuComplex *, 4446 const cuComplex *, int, cuComplex, cuComplex *, int); 4447 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpmv"); 4448 if (!func_ptr) LogFatalSymbolNotFound("cublasChpmv"); 4449 return func_ptr(uplo, n, alpha, AP, x, incx, beta, y, incy); 4450} 4451 4452void CUBLASWINAPI cublasZhpmv(char uplo, int n, cuDoubleComplex alpha, 4453 const cuDoubleComplex *AP, 4454 const cuDoubleComplex *x, int incx, 4455 cuDoubleComplex beta, cuDoubleComplex *y, 4456 int incy) { 4457 using FuncPtr = void(CUBLASWINAPI *)( 4458 char, int, cuDoubleComplex, const cuDoubleComplex *, 4459 const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int); 4460 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpmv"); 4461 if (!func_ptr) LogFatalSymbolNotFound("cublasZhpmv"); 4462 return func_ptr(uplo, n, alpha, AP, x, incx, beta, y, incy); 4463} 4464 4465void CUBLASWINAPI cublasSger(int m, int n, float alpha, const float *x, 4466 int incx, const float *y, int incy, float *A, 4467 int lda) { 4468 using FuncPtr = void(CUBLASWINAPI *)(int, int, float, const float *, int, 4469 const float *, int, float *, int); 4470 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSger"); 4471 if (!func_ptr) LogFatalSymbolNotFound("cublasSger"); 4472 return func_ptr(m, n, alpha, x, incx, y, incy, A, lda); 4473} 4474 4475void CUBLASWINAPI cublasDger(int m, int n, double alpha, const double *x, 4476 int incx, const double *y, int incy, double *A, 4477 int lda) { 4478 using FuncPtr = void(CUBLASWINAPI *)(int, int, double, const double *, int, 4479 const double *, int, double *, int); 4480 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDger"); 4481 if (!func_ptr) LogFatalSymbolNotFound("cublasDger"); 4482 return func_ptr(m, n, alpha, x, incx, y, incy, A, lda); 4483} 4484 4485void CUBLASWINAPI cublasCgeru(int m, int n, cuComplex alpha, const cuComplex *x, 4486 int incx, const cuComplex *y, int incy, 4487 cuComplex *A, int lda) { 4488 using FuncPtr = 4489 void(CUBLASWINAPI *)(int, int, cuComplex, const cuComplex *, int, 4490 const cuComplex *, int, cuComplex *, int); 4491 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgeru"); 4492 if (!func_ptr) LogFatalSymbolNotFound("cublasCgeru"); 4493 return func_ptr(m, n, alpha, x, incx, y, incy, A, lda); 4494} 4495 4496void CUBLASWINAPI cublasCgerc(int m, int n, cuComplex alpha, const cuComplex *x, 4497 int incx, const cuComplex *y, int incy, 4498 cuComplex *A, int lda) { 4499 using FuncPtr = 4500 void(CUBLASWINAPI *)(int, int, cuComplex, const cuComplex *, int, 4501 const cuComplex *, int, cuComplex *, int); 4502 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgerc"); 4503 if (!func_ptr) LogFatalSymbolNotFound("cublasCgerc"); 4504 return func_ptr(m, n, alpha, x, incx, y, incy, A, lda); 4505} 4506 4507void CUBLASWINAPI cublasZgeru(int m, int n, cuDoubleComplex alpha, 4508 const cuDoubleComplex *x, int incx, 4509 const cuDoubleComplex *y, int incy, 4510 cuDoubleComplex *A, int lda) { 4511 using FuncPtr = void(CUBLASWINAPI *)( 4512 int, int, cuDoubleComplex, const cuDoubleComplex *, int, 4513 const cuDoubleComplex *, int, cuDoubleComplex *, int); 4514 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgeru"); 4515 if (!func_ptr) LogFatalSymbolNotFound("cublasZgeru"); 4516 return func_ptr(m, n, alpha, x, incx, y, incy, A, lda); 4517} 4518 4519void CUBLASWINAPI cublasZgerc(int m, int n, cuDoubleComplex alpha, 4520 const cuDoubleComplex *x, int incx, 4521 const cuDoubleComplex *y, int incy, 4522 cuDoubleComplex *A, int lda) { 4523 using FuncPtr = void(CUBLASWINAPI *)( 4524 int, int, cuDoubleComplex, const cuDoubleComplex *, int, 4525 const cuDoubleComplex *, int, cuDoubleComplex *, int); 4526 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgerc"); 4527 if (!func_ptr) LogFatalSymbolNotFound("cublasZgerc"); 4528 return func_ptr(m, n, alpha, x, incx, y, incy, A, lda); 4529} 4530 4531void CUBLASWINAPI cublasSsyr(char uplo, int n, float alpha, const float *x, 4532 int incx, float *A, int lda) { 4533 using FuncPtr = 4534 void(CUBLASWINAPI *)(char, int, float, const float *, int, float *, int); 4535 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr"); 4536 if (!func_ptr) LogFatalSymbolNotFound("cublasSsyr"); 4537 return func_ptr(uplo, n, alpha, x, incx, A, lda); 4538} 4539 4540void CUBLASWINAPI cublasDsyr(char uplo, int n, double alpha, const double *x, 4541 int incx, double *A, int lda) { 4542 using FuncPtr = void(CUBLASWINAPI *)(char, int, double, const double *, int, 4543 double *, int); 4544 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr"); 4545 if (!func_ptr) LogFatalSymbolNotFound("cublasDsyr"); 4546 return func_ptr(uplo, n, alpha, x, incx, A, lda); 4547} 4548 4549void CUBLASWINAPI cublasCher(char uplo, int n, float alpha, const cuComplex *x, 4550 int incx, cuComplex *A, int lda) { 4551 using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const cuComplex *, int, 4552 cuComplex *, int); 4553 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher"); 4554 if (!func_ptr) LogFatalSymbolNotFound("cublasCher"); 4555 return func_ptr(uplo, n, alpha, x, incx, A, lda); 4556} 4557 4558void CUBLASWINAPI cublasZher(char uplo, int n, double alpha, 4559 const cuDoubleComplex *x, int incx, 4560 cuDoubleComplex *A, int lda) { 4561 using FuncPtr = void(CUBLASWINAPI *)( 4562 char, int, double, const cuDoubleComplex *, int, cuDoubleComplex *, int); 4563 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher"); 4564 if (!func_ptr) LogFatalSymbolNotFound("cublasZher"); 4565 return func_ptr(uplo, n, alpha, x, incx, A, lda); 4566} 4567 4568void CUBLASWINAPI cublasSspr(char uplo, int n, float alpha, const float *x, 4569 int incx, float *AP) { 4570 using FuncPtr = 4571 void(CUBLASWINAPI *)(char, int, float, const float *, int, float *); 4572 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspr"); 4573 if (!func_ptr) LogFatalSymbolNotFound("cublasSspr"); 4574 return func_ptr(uplo, n, alpha, x, incx, AP); 4575} 4576 4577void CUBLASWINAPI cublasDspr(char uplo, int n, double alpha, const double *x, 4578 int incx, double *AP) { 4579 using FuncPtr = 4580 void(CUBLASWINAPI *)(char, int, double, const double *, int, double *); 4581 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspr"); 4582 if (!func_ptr) LogFatalSymbolNotFound("cublasDspr"); 4583 return func_ptr(uplo, n, alpha, x, incx, AP); 4584} 4585 4586void CUBLASWINAPI cublasChpr(char uplo, int n, float alpha, const cuComplex *x, 4587 int incx, cuComplex *AP) { 4588 using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const cuComplex *, int, 4589 cuComplex *); 4590 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpr"); 4591 if (!func_ptr) LogFatalSymbolNotFound("cublasChpr"); 4592 return func_ptr(uplo, n, alpha, x, incx, AP); 4593} 4594 4595void CUBLASWINAPI cublasZhpr(char uplo, int n, double alpha, 4596 const cuDoubleComplex *x, int incx, 4597 cuDoubleComplex *AP) { 4598 using FuncPtr = void(CUBLASWINAPI *)( 4599 char, int, double, const cuDoubleComplex *, int, cuDoubleComplex *); 4600 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpr"); 4601 if (!func_ptr) LogFatalSymbolNotFound("cublasZhpr"); 4602 return func_ptr(uplo, n, alpha, x, incx, AP); 4603} 4604 4605void CUBLASWINAPI cublasSsyr2(char uplo, int n, float alpha, const float *x, 4606 int incx, const float *y, int incy, float *A, 4607 int lda) { 4608 using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const float *, int, 4609 const float *, int, float *, int); 4610 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr2"); 4611 if (!func_ptr) LogFatalSymbolNotFound("cublasSsyr2"); 4612 return func_ptr(uplo, n, alpha, x, incx, y, incy, A, lda); 4613} 4614 4615void CUBLASWINAPI cublasDsyr2(char uplo, int n, double alpha, const double *x, 4616 int incx, const double *y, int incy, double *A, 4617 int lda) { 4618 using FuncPtr = void(CUBLASWINAPI *)(char, int, double, const double *, int, 4619 const double *, int, double *, int); 4620 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr2"); 4621 if (!func_ptr) LogFatalSymbolNotFound("cublasDsyr2"); 4622 return func_ptr(uplo, n, alpha, x, incx, y, incy, A, lda); 4623} 4624 4625void CUBLASWINAPI cublasCher2(char uplo, int n, cuComplex alpha, 4626 const cuComplex *x, int incx, const cuComplex *y, 4627 int incy, cuComplex *A, int lda) { 4628 using FuncPtr = 4629 void(CUBLASWINAPI *)(char, int, cuComplex, const cuComplex *, int, 4630 const cuComplex *, int, cuComplex *, int); 4631 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher2"); 4632 if (!func_ptr) LogFatalSymbolNotFound("cublasCher2"); 4633 return func_ptr(uplo, n, alpha, x, incx, y, incy, A, lda); 4634} 4635 4636void CUBLASWINAPI cublasZher2(char uplo, int n, cuDoubleComplex alpha, 4637 const cuDoubleComplex *x, int incx, 4638 const cuDoubleComplex *y, int incy, 4639 cuDoubleComplex *A, int lda) { 4640 using FuncPtr = void(CUBLASWINAPI *)( 4641 char, int, cuDoubleComplex, const cuDoubleComplex *, int, 4642 const cuDoubleComplex *, int, cuDoubleComplex *, int); 4643 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher2"); 4644 if (!func_ptr) LogFatalSymbolNotFound("cublasZher2"); 4645 return func_ptr(uplo, n, alpha, x, incx, y, incy, A, lda); 4646} 4647 4648void CUBLASWINAPI cublasSspr2(char uplo, int n, float alpha, const float *x, 4649 int incx, const float *y, int incy, float *AP) { 4650 using FuncPtr = void(CUBLASWINAPI *)(char, int, float, const float *, int, 4651 const float *, int, float *); 4652 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSspr2"); 4653 if (!func_ptr) LogFatalSymbolNotFound("cublasSspr2"); 4654 return func_ptr(uplo, n, alpha, x, incx, y, incy, AP); 4655} 4656 4657void CUBLASWINAPI cublasDspr2(char uplo, int n, double alpha, const double *x, 4658 int incx, const double *y, int incy, double *AP) { 4659 using FuncPtr = void(CUBLASWINAPI *)(char, int, double, const double *, int, 4660 const double *, int, double *); 4661 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDspr2"); 4662 if (!func_ptr) LogFatalSymbolNotFound("cublasDspr2"); 4663 return func_ptr(uplo, n, alpha, x, incx, y, incy, AP); 4664} 4665 4666void CUBLASWINAPI cublasChpr2(char uplo, int n, cuComplex alpha, 4667 const cuComplex *x, int incx, const cuComplex *y, 4668 int incy, cuComplex *AP) { 4669 using FuncPtr = 4670 void(CUBLASWINAPI *)(char, int, cuComplex, const cuComplex *, int, 4671 const cuComplex *, int, cuComplex *); 4672 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChpr2"); 4673 if (!func_ptr) LogFatalSymbolNotFound("cublasChpr2"); 4674 return func_ptr(uplo, n, alpha, x, incx, y, incy, AP); 4675} 4676 4677void CUBLASWINAPI cublasZhpr2(char uplo, int n, cuDoubleComplex alpha, 4678 const cuDoubleComplex *x, int incx, 4679 const cuDoubleComplex *y, int incy, 4680 cuDoubleComplex *AP) { 4681 using FuncPtr = void(CUBLASWINAPI *)( 4682 char, int, cuDoubleComplex, const cuDoubleComplex *, int, 4683 const cuDoubleComplex *, int, cuDoubleComplex *); 4684 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhpr2"); 4685 if (!func_ptr) LogFatalSymbolNotFound("cublasZhpr2"); 4686 return func_ptr(uplo, n, alpha, x, incx, y, incy, AP); 4687} 4688 4689void CUBLASWINAPI cublasSgemm(char transa, char transb, int m, int n, int k, 4690 float alpha, const float *A, int lda, 4691 const float *B, int ldb, float beta, float *C, 4692 int ldc) { 4693 using FuncPtr = 4694 void(CUBLASWINAPI *)(char, char, int, int, int, float, const float *, int, 4695 const float *, int, float, float *, int); 4696 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSgemm"); 4697 if (!func_ptr) LogFatalSymbolNotFound("cublasSgemm"); 4698 return func_ptr(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc); 4699} 4700 4701void CUBLASWINAPI cublasDgemm(char transa, char transb, int m, int n, int k, 4702 double alpha, const double *A, int lda, 4703 const double *B, int ldb, double beta, double *C, 4704 int ldc) { 4705 using FuncPtr = 4706 void(CUBLASWINAPI *)(char, char, int, int, int, double, const double *, 4707 int, const double *, int, double, double *, int); 4708 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDgemm"); 4709 if (!func_ptr) LogFatalSymbolNotFound("cublasDgemm"); 4710 return func_ptr(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc); 4711} 4712 4713void CUBLASWINAPI cublasCgemm(char transa, char transb, int m, int n, int k, 4714 cuComplex alpha, const cuComplex *A, int lda, 4715 const cuComplex *B, int ldb, cuComplex beta, 4716 cuComplex *C, int ldc) { 4717 using FuncPtr = void(CUBLASWINAPI *)( 4718 char, char, int, int, int, cuComplex, const cuComplex *, int, 4719 const cuComplex *, int, cuComplex, cuComplex *, int); 4720 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCgemm"); 4721 if (!func_ptr) LogFatalSymbolNotFound("cublasCgemm"); 4722 return func_ptr(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc); 4723} 4724 4725void CUBLASWINAPI cublasZgemm(char transa, char transb, int m, int n, int k, 4726 cuDoubleComplex alpha, const cuDoubleComplex *A, 4727 int lda, const cuDoubleComplex *B, int ldb, 4728 cuDoubleComplex beta, cuDoubleComplex *C, 4729 int ldc) { 4730 using FuncPtr = void(CUBLASWINAPI *)( 4731 char, char, int, int, int, cuDoubleComplex, const cuDoubleComplex *, int, 4732 const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int); 4733 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZgemm"); 4734 if (!func_ptr) LogFatalSymbolNotFound("cublasZgemm"); 4735 return func_ptr(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc); 4736} 4737 4738void CUBLASWINAPI cublasSsyrk(char uplo, char trans, int n, int k, float alpha, 4739 const float *A, int lda, float beta, float *C, 4740 int ldc) { 4741 using FuncPtr = void(CUBLASWINAPI *)(char, char, int, int, float, 4742 const float *, int, float, float *, int); 4743 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyrk"); 4744 if (!func_ptr) LogFatalSymbolNotFound("cublasSsyrk"); 4745 return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 4746} 4747 4748void CUBLASWINAPI cublasDsyrk(char uplo, char trans, int n, int k, double alpha, 4749 const double *A, int lda, double beta, double *C, 4750 int ldc) { 4751 using FuncPtr = void(CUBLASWINAPI *)( 4752 char, char, int, int, double, const double *, int, double, double *, int); 4753 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyrk"); 4754 if (!func_ptr) LogFatalSymbolNotFound("cublasDsyrk"); 4755 return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 4756} 4757 4758void CUBLASWINAPI cublasCsyrk(char uplo, char trans, int n, int k, 4759 cuComplex alpha, const cuComplex *A, int lda, 4760 cuComplex beta, cuComplex *C, int ldc) { 4761 using FuncPtr = 4762 void(CUBLASWINAPI *)(char, char, int, int, cuComplex, const cuComplex *, 4763 int, cuComplex, cuComplex *, int); 4764 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyrk"); 4765 if (!func_ptr) LogFatalSymbolNotFound("cublasCsyrk"); 4766 return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 4767} 4768 4769void CUBLASWINAPI cublasZsyrk(char uplo, char trans, int n, int k, 4770 cuDoubleComplex alpha, const cuDoubleComplex *A, 4771 int lda, cuDoubleComplex beta, cuDoubleComplex *C, 4772 int ldc) { 4773 using FuncPtr = void(CUBLASWINAPI *)(char, char, int, int, cuDoubleComplex, 4774 const cuDoubleComplex *, int, 4775 cuDoubleComplex, cuDoubleComplex *, int); 4776 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyrk"); 4777 if (!func_ptr) LogFatalSymbolNotFound("cublasZsyrk"); 4778 return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 4779} 4780 4781void CUBLASWINAPI cublasCherk(char uplo, char trans, int n, int k, float alpha, 4782 const cuComplex *A, int lda, float beta, 4783 cuComplex *C, int ldc) { 4784 using FuncPtr = 4785 void(CUBLASWINAPI *)(char, char, int, int, float, const cuComplex *, int, 4786 float, cuComplex *, int); 4787 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCherk"); 4788 if (!func_ptr) LogFatalSymbolNotFound("cublasCherk"); 4789 return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 4790} 4791 4792void CUBLASWINAPI cublasZherk(char uplo, char trans, int n, int k, double alpha, 4793 const cuDoubleComplex *A, int lda, double beta, 4794 cuDoubleComplex *C, int ldc) { 4795 using FuncPtr = void(CUBLASWINAPI *)(char, char, int, int, double, 4796 const cuDoubleComplex *, int, double, 4797 cuDoubleComplex *, int); 4798 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZherk"); 4799 if (!func_ptr) LogFatalSymbolNotFound("cublasZherk"); 4800 return func_ptr(uplo, trans, n, k, alpha, A, lda, beta, C, ldc); 4801} 4802 4803void CUBLASWINAPI cublasSsyr2k(char uplo, char trans, int n, int k, float alpha, 4804 const float *A, int lda, const float *B, int ldb, 4805 float beta, float *C, int ldc) { 4806 using FuncPtr = 4807 void(CUBLASWINAPI *)(char, char, int, int, float, const float *, int, 4808 const float *, int, float, float *, int); 4809 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsyr2k"); 4810 if (!func_ptr) LogFatalSymbolNotFound("cublasSsyr2k"); 4811 return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc); 4812} 4813 4814void CUBLASWINAPI cublasDsyr2k(char uplo, char trans, int n, int k, 4815 double alpha, const double *A, int lda, 4816 const double *B, int ldb, double beta, double *C, 4817 int ldc) { 4818 using FuncPtr = 4819 void(CUBLASWINAPI *)(char, char, int, int, double, const double *, int, 4820 const double *, int, double, double *, int); 4821 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsyr2k"); 4822 if (!func_ptr) LogFatalSymbolNotFound("cublasDsyr2k"); 4823 return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc); 4824} 4825 4826void CUBLASWINAPI cublasCsyr2k(char uplo, char trans, int n, int k, 4827 cuComplex alpha, const cuComplex *A, int lda, 4828 const cuComplex *B, int ldb, cuComplex beta, 4829 cuComplex *C, int ldc) { 4830 using FuncPtr = void(CUBLASWINAPI *)( 4831 char, char, int, int, cuComplex, const cuComplex *, int, 4832 const cuComplex *, int, cuComplex, cuComplex *, int); 4833 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsyr2k"); 4834 if (!func_ptr) LogFatalSymbolNotFound("cublasCsyr2k"); 4835 return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc); 4836} 4837 4838void CUBLASWINAPI cublasZsyr2k(char uplo, char trans, int n, int k, 4839 cuDoubleComplex alpha, const cuDoubleComplex *A, 4840 int lda, const cuDoubleComplex *B, int ldb, 4841 cuDoubleComplex beta, cuDoubleComplex *C, 4842 int ldc) { 4843 using FuncPtr = void(CUBLASWINAPI *)( 4844 char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, 4845 const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int); 4846 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsyr2k"); 4847 if (!func_ptr) LogFatalSymbolNotFound("cublasZsyr2k"); 4848 return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc); 4849} 4850 4851void CUBLASWINAPI cublasCher2k(char uplo, char trans, int n, int k, 4852 cuComplex alpha, const cuComplex *A, int lda, 4853 const cuComplex *B, int ldb, float beta, 4854 cuComplex *C, int ldc) { 4855 using FuncPtr = void(CUBLASWINAPI *)( 4856 char, char, int, int, cuComplex, const cuComplex *, int, 4857 const cuComplex *, int, float, cuComplex *, int); 4858 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCher2k"); 4859 if (!func_ptr) LogFatalSymbolNotFound("cublasCher2k"); 4860 return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc); 4861} 4862 4863void CUBLASWINAPI cublasZher2k(char uplo, char trans, int n, int k, 4864 cuDoubleComplex alpha, const cuDoubleComplex *A, 4865 int lda, const cuDoubleComplex *B, int ldb, 4866 double beta, cuDoubleComplex *C, int ldc) { 4867 using FuncPtr = void(CUBLASWINAPI *)( 4868 char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, 4869 const cuDoubleComplex *, int, double, cuDoubleComplex *, int); 4870 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZher2k"); 4871 if (!func_ptr) LogFatalSymbolNotFound("cublasZher2k"); 4872 return func_ptr(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc); 4873} 4874 4875void CUBLASWINAPI cublasSsymm(char side, char uplo, int m, int n, float alpha, 4876 const float *A, int lda, const float *B, int ldb, 4877 float beta, float *C, int ldc) { 4878 using FuncPtr = 4879 void(CUBLASWINAPI *)(char, char, int, int, float, const float *, int, 4880 const float *, int, float, float *, int); 4881 static auto func_ptr = LoadSymbol<FuncPtr>("cublasSsymm"); 4882 if (!func_ptr) LogFatalSymbolNotFound("cublasSsymm"); 4883 return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc); 4884} 4885 4886void CUBLASWINAPI cublasDsymm(char side, char uplo, int m, int n, double alpha, 4887 const double *A, int lda, const double *B, 4888 int ldb, double beta, double *C, int ldc) { 4889 using FuncPtr = 4890 void(CUBLASWINAPI *)(char, char, int, int, double, const double *, int, 4891 const double *, int, double, double *, int); 4892 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDsymm"); 4893 if (!func_ptr) LogFatalSymbolNotFound("cublasDsymm"); 4894 return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc); 4895} 4896 4897void CUBLASWINAPI cublasCsymm(char side, char uplo, int m, int n, 4898 cuComplex alpha, const cuComplex *A, int lda, 4899 const cuComplex *B, int ldb, cuComplex beta, 4900 cuComplex *C, int ldc) { 4901 using FuncPtr = void(CUBLASWINAPI *)( 4902 char, char, int, int, cuComplex, const cuComplex *, int, 4903 const cuComplex *, int, cuComplex, cuComplex *, int); 4904 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCsymm"); 4905 if (!func_ptr) LogFatalSymbolNotFound("cublasCsymm"); 4906 return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc); 4907} 4908 4909void CUBLASWINAPI cublasZsymm(char side, char uplo, int m, int n, 4910 cuDoubleComplex alpha, const cuDoubleComplex *A, 4911 int lda, const cuDoubleComplex *B, int ldb, 4912 cuDoubleComplex beta, cuDoubleComplex *C, 4913 int ldc) { 4914 using FuncPtr = void(CUBLASWINAPI *)( 4915 char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, 4916 const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int); 4917 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZsymm"); 4918 if (!func_ptr) LogFatalSymbolNotFound("cublasZsymm"); 4919 return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc); 4920} 4921 4922void CUBLASWINAPI cublasChemm(char side, char uplo, int m, int n, 4923 cuComplex alpha, const cuComplex *A, int lda, 4924 const cuComplex *B, int ldb, cuComplex beta, 4925 cuComplex *C, int ldc) { 4926 using FuncPtr = void(CUBLASWINAPI *)( 4927 char, char, int, int, cuComplex, const cuComplex *, int, 4928 const cuComplex *, int, cuComplex, cuComplex *, int); 4929 static auto func_ptr = LoadSymbol<FuncPtr>("cublasChemm"); 4930 if (!func_ptr) LogFatalSymbolNotFound("cublasChemm"); 4931 return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc); 4932} 4933 4934void CUBLASWINAPI cublasZhemm(char side, char uplo, int m, int n, 4935 cuDoubleComplex alpha, const cuDoubleComplex *A, 4936 int lda, const cuDoubleComplex *B, int ldb, 4937 cuDoubleComplex beta, cuDoubleComplex *C, 4938 int ldc) { 4939 using FuncPtr = void(CUBLASWINAPI *)( 4940 char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, 4941 const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int); 4942 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZhemm"); 4943 if (!func_ptr) LogFatalSymbolNotFound("cublasZhemm"); 4944 return func_ptr(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc); 4945} 4946 4947void CUBLASWINAPI cublasStrsm(char side, char uplo, char transa, char diag, 4948 int m, int n, float alpha, const float *A, 4949 int lda, float *B, int ldb) { 4950 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int, float, 4951 const float *, int, float *, int); 4952 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrsm"); 4953 if (!func_ptr) LogFatalSymbolNotFound("cublasStrsm"); 4954 return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb); 4955} 4956 4957void CUBLASWINAPI cublasDtrsm(char side, char uplo, char transa, char diag, 4958 int m, int n, double alpha, const double *A, 4959 int lda, double *B, int ldb) { 4960 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int, double, 4961 const double *, int, double *, int); 4962 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrsm"); 4963 if (!func_ptr) LogFatalSymbolNotFound("cublasDtrsm"); 4964 return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb); 4965} 4966 4967void CUBLASWINAPI cublasCtrsm(char side, char uplo, char transa, char diag, 4968 int m, int n, cuComplex alpha, const cuComplex *A, 4969 int lda, cuComplex *B, int ldb) { 4970 using FuncPtr = 4971 void(CUBLASWINAPI *)(char, char, char, char, int, int, cuComplex, 4972 const cuComplex *, int, cuComplex *, int); 4973 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrsm"); 4974 if (!func_ptr) LogFatalSymbolNotFound("cublasCtrsm"); 4975 return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb); 4976} 4977 4978void CUBLASWINAPI cublasZtrsm(char side, char uplo, char transa, char diag, 4979 int m, int n, cuDoubleComplex alpha, 4980 const cuDoubleComplex *A, int lda, 4981 cuDoubleComplex *B, int ldb) { 4982 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int, 4983 cuDoubleComplex, const cuDoubleComplex *, 4984 int, cuDoubleComplex *, int); 4985 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrsm"); 4986 if (!func_ptr) LogFatalSymbolNotFound("cublasZtrsm"); 4987 return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb); 4988} 4989 4990void CUBLASWINAPI cublasStrmm(char side, char uplo, char transa, char diag, 4991 int m, int n, float alpha, const float *A, 4992 int lda, float *B, int ldb) { 4993 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int, float, 4994 const float *, int, float *, int); 4995 static auto func_ptr = LoadSymbol<FuncPtr>("cublasStrmm"); 4996 if (!func_ptr) LogFatalSymbolNotFound("cublasStrmm"); 4997 return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb); 4998} 4999 5000void CUBLASWINAPI cublasDtrmm(char side, char uplo, char transa, char diag, 5001 int m, int n, double alpha, const double *A, 5002 int lda, double *B, int ldb) { 5003 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int, double, 5004 const double *, int, double *, int); 5005 static auto func_ptr = LoadSymbol<FuncPtr>("cublasDtrmm"); 5006 if (!func_ptr) LogFatalSymbolNotFound("cublasDtrmm"); 5007 return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb); 5008} 5009 5010void CUBLASWINAPI cublasCtrmm(char side, char uplo, char transa, char diag, 5011 int m, int n, cuComplex alpha, const cuComplex *A, 5012 int lda, cuComplex *B, int ldb) { 5013 using FuncPtr = 5014 void(CUBLASWINAPI *)(char, char, char, char, int, int, cuComplex, 5015 const cuComplex *, int, cuComplex *, int); 5016 static auto func_ptr = LoadSymbol<FuncPtr>("cublasCtrmm"); 5017 if (!func_ptr) LogFatalSymbolNotFound("cublasCtrmm"); 5018 return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb); 5019} 5020 5021void CUBLASWINAPI cublasZtrmm(char side, char uplo, char transa, char diag, 5022 int m, int n, cuDoubleComplex alpha, 5023 const cuDoubleComplex *A, int lda, 5024 cuDoubleComplex *B, int ldb) { 5025 using FuncPtr = void(CUBLASWINAPI *)(char, char, char, char, int, int, 5026 cuDoubleComplex, const cuDoubleComplex *, 5027 int, cuDoubleComplex *, int); 5028 static auto func_ptr = LoadSymbol<FuncPtr>("cublasZtrmm"); 5029 if (!func_ptr) LogFatalSymbolNotFound("cublasZtrmm"); 5030 return func_ptr(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb); 5031} 5032 5033} // extern "C" 5034