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