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