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