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