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