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