util/X86LINUX64/cuda-6.5/include/cublas_api.h

   1 /*
   2  * Copyright 1993-2014 NVIDIA Corporation.  All rights reserved.
   3  *
   4  * NOTICE TO LICENSEE:
   5  *
   6  * This source code and/or documentation ("Licensed Deliverables") are
   7  * subject to NVIDIA intellectual property rights under U.S. and
   8  * international Copyright laws.
   9  *
  10  * These Licensed Deliverables contained herein is PROPRIETARY and
  11  * CONFIDENTIAL to NVIDIA and is being provided under the terms and
  12  * conditions of a form of NVIDIA software license agreement by and
  13  * between NVIDIA and Licensee ("License Agreement") or electronically
  14  * accepted by Licensee.  Notwithstanding any terms or conditions to
  15  * the contrary in the License Agreement, reproduction or disclosure
  16  * of the Licensed Deliverables to any third party without the express
  17  * written consent of NVIDIA is prohibited.
  18  *
  19  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
  20  * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
  21  * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  IT IS
  22  * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
  23  * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
  24  * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
  25  * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
  26  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
  27  * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
  28  * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
  29  * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  30  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  31  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  32  * OF THESE LICENSED DELIVERABLES.
  33  *
  34  * U.S. Government End Users.  These Licensed Deliverables are a
  35  * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
  36  * 1995), consisting of "commercial computer software" and "commercial
  37  * computer software documentation" as such terms are used in 48
  38  * C.F.R. 12.212 (SEPT 1995) and is provided to the U.S. Government
  39  * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and
  40  * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
  41  * U.S. Government End Users acquire the Licensed Deliverables with
  42  * only those rights set forth herein.
  43  *
  44  * Any use of the Licensed Deliverables in individual and commercial
  45  * software must include, in the user documentation and internal
  46  * comments to the code, the above Disclaimer and U.S. Government End
  47  * Users Notice.
  48  */
  49
  50 /*
  51  * This is the public header file for the CUBLAS library, defining the API
  52  *
  53  * CUBLAS is an implementation of BLAS (Basic Linear Algebra Subroutines)
  54  * on top of the CUDA runtime.
  55  */
  56
  57 #if !defined(CUBLAS_API_H_)
  58 #define CUBLAS_API_H_
  59
  60 #ifndef CUBLASWINAPI
  61 #ifdef _WIN32
  62 #define CUBLASWINAPI __stdcall
  63 #else
  64 #define CUBLASWINAPI
  65 #endif
  66 #endif
  67
  68 #ifndef CUBLASAPI
  69 #error "This file should not be included without defining CUBLASAPI"
  70 #endif
  71
  72 #include "driver_types.h"
  73 #include "cuComplex.h"   /* import complex data type */
  74
  75 #if defined(__cplusplus)
  76 extern "C" {
  77 #endif /* __cplusplus */
  78
  79 /* CUBLAS status type returns */
  80 typedef enum{
  81     CUBLAS_STATUS_SUCCESS         =0,
  82     CUBLAS_STATUS_NOT_INITIALIZED =1,
  83     CUBLAS_STATUS_ALLOC_FAILED    =3,
  84     CUBLAS_STATUS_INVALID_VALUE   =7,
  85     CUBLAS_STATUS_ARCH_MISMATCH   =8,
  86     CUBLAS_STATUS_MAPPING_ERROR   =11,
  87     CUBLAS_STATUS_EXECUTION_FAILED=13,
  88     CUBLAS_STATUS_INTERNAL_ERROR  =14,
  89     CUBLAS_STATUS_NOT_SUPPORTED   =15,
  90     CUBLAS_STATUS_LICENSE_ERROR   =16
  91 } cublasStatus_t;
  92
  93
  94 typedef enum {
  95     CUBLAS_FILL_MODE_LOWER=0,
  96     CUBLAS_FILL_MODE_UPPER=1
  97 } cublasFillMode_t;
  98
  99 typedef enum {
 100     CUBLAS_DIAG_NON_UNIT=0,
 101     CUBLAS_DIAG_UNIT=1
 102 } cublasDiagType_t;
 103
 104 typedef enum {
 105     CUBLAS_SIDE_LEFT =0,
 106     CUBLAS_SIDE_RIGHT=1
 107 } cublasSideMode_t;
 108
 109
 110 typedef enum {
 111     CUBLAS_OP_N=0,
 112     CUBLAS_OP_T=1,
 113     CUBLAS_OP_C=2
 114 } cublasOperation_t;
 115
 116
 117 typedef enum {
 118     CUBLAS_POINTER_MODE_HOST   = 0,
 119     CUBLAS_POINTER_MODE_DEVICE = 1
 120 } cublasPointerMode_t;
 121
 122 typedef enum {
 123     CUBLAS_ATOMICS_NOT_ALLOWED   = 0,
 124     CUBLAS_ATOMICS_ALLOWED       = 1
 125 } cublasAtomicsMode_t;
 126
 127 /* Opaque structure holding CUBLAS library context */
 128 struct cublasContext;
 129 typedef struct cublasContext *cublasHandle_t;
 130
 131 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCreate_v2 (cublasHandle_t *handle);
 132 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDestroy_v2 (cublasHandle_t handle);
 133 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasGetVersion_v2(cublasHandle_t handle, int *version);
 134 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSetStream_v2 (cublasHandle_t handle, cudaStream_t streamId);
 135 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasGetStream_v2 (cublasHandle_t handle, cudaStream_t *streamId);
 136
 137 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasGetPointerMode_v2 (cublasHandle_t handle, cublasPointerMode_t *mode);
 138 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSetPointerMode_v2 (cublasHandle_t handle, cublasPointerMode_t mode);
 139
 140 CUBLASAPI cublasStatus_t  CUBLASWINAPI cublasGetAtomicsMode(cublasHandle_t handle, cublasAtomicsMode_t *mode);
 141 CUBLASAPI cublasStatus_t  CUBLASWINAPI cublasSetAtomicsMode(cublasHandle_t handle, cublasAtomicsMode_t mode);
 142
 143 /*
 144  * cublasStatus_t
 145  * cublasSetVector (int n, int elemSize, const void *x, int incx,
 146  *                  void *y, int incy)
 147  *
 148  * copies n elements from a vector x in CPU memory space to a vector y
 149  * in GPU memory space. Elements in both vectors are assumed to have a
 150  * size of elemSize bytes. Storage spacing between consecutive elements
 151  * is incx for the source vector x and incy for the destination vector
 152  * y. In general, y points to an object, or part of an object, allocated
 153  * via cublasAlloc(). Column major format for two-dimensional matrices
 154  * is assumed throughout CUBLAS. Therefore, if the increment for a vector
 155  * is equal to 1, this access a column vector while using an increment
 156  * equal to the leading dimension of the respective matrix accesses a
 157  * row vector.
 158  *
 159  * Return Values
 160  * -------------
 161  * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized
 162  * CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0
 163  * CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory
 164  * CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 165  */
 166 cublasStatus_t CUBLASWINAPI cublasSetVector (int n, int elemSize, const void *x,
 167                                              int incx, void *devicePtr, int incy);
 168
 169 /*
 170  * cublasStatus_t
 171  * cublasGetVector (int n, int elemSize, const void *x, int incx,
 172  *                  void *y, int incy)
 173  *
 174  * copies n elements from a vector x in GPU memory space to a vector y
 175  * in CPU memory space. Elements in both vectors are assumed to have a
 176  * size of elemSize bytes. Storage spacing between consecutive elements
 177  * is incx for the source vector x and incy for the destination vector
 178  * y. In general, x points to an object, or part of an object, allocated
 179  * via cublasAlloc(). Column major format for two-dimensional matrices
 180  * is assumed throughout CUBLAS. Therefore, if the increment for a vector
 181  * is equal to 1, this access a column vector while using an increment
 182  * equal to the leading dimension of the respective matrix accesses a
 183  * row vector.
 184  *
 185  * Return Values
 186  * -------------
 187  * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized
 188  * CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0
 189  * CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory
 190  * CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 191  */
 192 cublasStatus_t CUBLASWINAPI cublasGetVector (int n, int elemSize, const void *x,
 193                                              int incx, void *y, int incy);
 194
 195 /*
 196  * cublasStatus_t
 197  * cublasSetMatrix (int rows, int cols, int elemSize, const void *A,
 198  *                  int lda, void *B, int ldb)
 199  *
 200  * copies a tile of rows x cols elements from a matrix A in CPU memory
 201  * space to a matrix B in GPU memory space. Each element requires storage
 202  * of elemSize bytes. Both matrices are assumed to be stored in column
 203  * major format, with the leading dimension (i.e. number of rows) of
 204  * source matrix A provided in lda, and the leading dimension of matrix B
 205  * provided in ldb. In general, B points to an object, or part of an
 206  * object, that was allocated via cublasAlloc().
 207  *
 208  * Return Values
 209  * -------------
 210  * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized
 211  * CUBLAS_STATUS_INVALID_VALUE    if rows or cols < 0, or elemSize, lda, or
 212  *                                ldb <= 0
 213  * CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory
 214  * CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 215  */
 216 cublasStatus_t CUBLASWINAPI cublasSetMatrix (int rows, int cols, int elemSize,
 217                                              const void *A, int lda, void *B,
 218                                              int ldb);
 219
 220 /*
 221  * cublasStatus_t
 222  * cublasGetMatrix (int rows, int cols, int elemSize, const void *A,
 223  *                  int lda, void *B, int ldb)
 224  *
 225  * copies a tile of rows x cols elements from a matrix A in GPU memory
 226  * space to a matrix B in CPU memory space. Each element requires storage
 227  * of elemSize bytes. Both matrices are assumed to be stored in column
 228  * major format, with the leading dimension (i.e. number of rows) of
 229  * source matrix A provided in lda, and the leading dimension of matrix B
 230  * provided in ldb. In general, A points to an object, or part of an
 231  * object, that was allocated via cublasAlloc().
 232  *
 233  * Return Values
 234  * -------------
 235  * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized
 236  * CUBLAS_STATUS_INVALID_VALUE    if rows, cols, eleSize, lda, or ldb <= 0
 237  * CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory
 238  * CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 239  */
 240 cublasStatus_t CUBLASWINAPI cublasGetMatrix (int rows, int cols, int elemSize,
 241                                              const void *A, int lda, void *B,
 242                                              int ldb);
 243
 244 /*
 245  * cublasStatus
 246  * cublasSetVectorAsync ( int n, int elemSize, const void *x, int incx,
 247  *                       void *y, int incy, cudaStream_t stream );
 248  *
 249  * cublasSetVectorAsync has the same functionnality as cublasSetVector
 250  * but the transfer is done asynchronously within the CUDA stream passed
 251  * in parameter.
 252  *
 253  * Return Values
 254  * -------------
 255  * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized
 256  * CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0
 257  * CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory
 258  * CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 259  */
 260 cublasStatus_t CUBLASWINAPI cublasSetVectorAsync (int n, int elemSize,
 261                                                   const void *hostPtr, int incx,
 262                                                   void *devicePtr, int incy,
 263                                                   cudaStream_t stream);
 264 /*
 265  * cublasStatus
 266  * cublasGetVectorAsync( int n, int elemSize, const void *x, int incx,
 267  *                       void *y, int incy, cudaStream_t stream)
 268  *
 269  * cublasGetVectorAsync has the same functionnality as cublasGetVector
 270  * but the transfer is done asynchronously within the CUDA stream passed
 271  * in parameter.
 272  *
 273  * Return Values
 274  * -------------
 275  * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized
 276  * CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0
 277  * CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory
 278  * CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 279  */
 280 cublasStatus_t CUBLASWINAPI cublasGetVectorAsync (int n, int elemSize,
 281                                                   const void *devicePtr, int incx,
 282                                                   void *hostPtr, int incy,
 283                                                   cudaStream_t stream);
 284
 285 /*
 286  * cublasStatus_t
 287  * cublasSetMatrixAsync (int rows, int cols, int elemSize, const void *A,
 288  *                       int lda, void *B, int ldb, cudaStream_t stream)
 289  *
 290  * cublasSetMatrixAsync has the same functionnality as cublasSetMatrix
 291  * but the transfer is done asynchronously within the CUDA stream passed
 292  * in parameter.
 293  *
 294  * Return Values
 295  * -------------
 296  * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized
 297  * CUBLAS_STATUS_INVALID_VALUE    if rows or cols < 0, or elemSize, lda, or
 298  *                                ldb <= 0
 299  * CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory
 300  * CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 301  */
 302 cublasStatus_t CUBLASWINAPI cublasSetMatrixAsync (int rows, int cols, int elemSize,
 303                                                   const void *A, int lda, void *B,
 304                                                   int ldb, cudaStream_t stream);
 305
 306 /*
 307  * cublasStatus_t
 308  * cublasGetMatrixAsync (int rows, int cols, int elemSize, const void *A,
 309  *                       int lda, void *B, int ldb, cudaStream_t stream)
 310  *
 311  * cublasGetMatrixAsync has the same functionnality as cublasGetMatrix
 312  * but the transfer is done asynchronously within the CUDA stream passed
 313  * in parameter.
 314  *
 315  * Return Values
 316  * -------------
 317  * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized
 318  * CUBLAS_STATUS_INVALID_VALUE    if rows, cols, eleSize, lda, or ldb <= 0
 319  * CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory
 320  * CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 321  */
 322 cublasStatus_t CUBLASWINAPI cublasGetMatrixAsync (int rows, int cols, int elemSize,
 323                                                   const void *A, int lda, void *B,
 324                                                   int ldb, cudaStream_t stream);
 325
 326
 327 CUBLASAPI void CUBLASWINAPI cublasXerbla (const char *srName, int info);
 328 /* ---------------- CUBLAS BLAS1 functions ---------------- */
 329 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSnrm2_v2(cublasHandle_t handle,
 330                                                      int n,
 331                                                      const float *x,
 332                                                      int incx,
 333                                                      float *result); /* host or device pointer */
 334
 335 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDnrm2_v2(cublasHandle_t handle,
 336                                                      int n,
 337                                                      const double *x,
 338                                                      int incx,
 339                                                      double *result);  /* host or device pointer */
 340
 341 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasScnrm2_v2(cublasHandle_t handle,
 342                                                       int n,
 343                                                       const cuComplex *x,
 344                                                       int incx,
 345                                                       float *result);  /* host or device pointer */
 346
 347 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDznrm2_v2(cublasHandle_t handle,
 348                                                       int n,
 349                                                       const cuDoubleComplex *x,
 350                                                       int incx,
 351                                                       double *result);  /* host or device pointer */
 352
 353 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSdot_v2 (cublasHandle_t handle,
 354                                                      int n,
 355                                                      const float *x,
 356                                                      int incx,
 357                                                      const float *y,
 358                                                      int incy,
 359                                                      float *result);  /* host or device pointer */
 360
 361 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDdot_v2 (cublasHandle_t handle,
 362                                                      int n,
 363                                                      const double *x,
 364                                                      int incx,
 365                                                      const double *y,
 366                                                      int incy,
 367                                                      double *result);  /* host or device pointer */
 368
 369 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCdotu_v2 (cublasHandle_t handle,
 370                                                       int n,
 371                                                       const cuComplex *x,
 372                                                       int incx,
 373                                                       const cuComplex *y,
 374                                                       int incy,
 375                                                       cuComplex *result);  /* host or device pointer */
 376
 377 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCdotc_v2 (cublasHandle_t handle,
 378                                                       int n,
 379                                                       const cuComplex *x,
 380                                                       int incx,
 381                                                       const cuComplex *y,
 382                                                       int incy,
 383                                                       cuComplex *result); /* host or device pointer */
 384
 385 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZdotu_v2 (cublasHandle_t handle,
 386                                                       int n,
 387                                                       const cuDoubleComplex *x,
 388                                                       int incx,
 389                                                       const cuDoubleComplex *y,
 390                                                       int incy,
 391                                                       cuDoubleComplex *result); /* host or device pointer */
 392
 393 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZdotc_v2 (cublasHandle_t handle,
 394                                                       int n,
 395                                                       const cuDoubleComplex *x,
 396                                                       int incx,
 397                                                       const cuDoubleComplex *y,
 398                                                       int incy,
 399                                                       cuDoubleComplex *result); /* host or device pointer */
 400
 401 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSscal_v2(cublasHandle_t handle,
 402                                                      int n,
 403                                                      const float *alpha,  /* host or device pointer */
 404                                                      float *x,
 405                                                      int incx);
 406
 407 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDscal_v2(cublasHandle_t handle,
 408                                                      int n,
 409                                                      const double *alpha,  /* host or device pointer */
 410                                                      double *x,
 411                                                      int incx);
 412
 413 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCscal_v2(cublasHandle_t handle,
 414                                                      int n,
 415                                                      const cuComplex *alpha, /* host or device pointer */
 416                                                      cuComplex *x,
 417                                                      int incx);
 418
 419 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCsscal_v2(cublasHandle_t handle,
 420                                                       int n,
 421                                                       const float *alpha, /* host or device pointer */
 422                                                       cuComplex *x,
 423                                                       int incx);
 424
 425 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZscal_v2(cublasHandle_t handle,
 426                                                      int n,
 427                                                      const cuDoubleComplex *alpha, /* host or device pointer */
 428                                                      cuDoubleComplex *x,
 429                                                      int incx);
 430
 431 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZdscal_v2(cublasHandle_t handle,
 432                                                       int n,
 433                                                       const double *alpha, /* host or device pointer */
 434                                                       cuDoubleComplex *x,
 435                                                       int incx);
 436
 437 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSaxpy_v2 (cublasHandle_t handle,
 438                                                       int n,
 439                                                       const float *alpha, /* host or device pointer */
 440                                                       const float *x,
 441                                                       int incx,
 442                                                       float *y,
 443                                                       int incy);
 444
 445 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDaxpy_v2 (cublasHandle_t handle,
 446                                                       int n,
 447                                                       const double *alpha, /* host or device pointer */
 448                                                       const double *x,
 449                                                       int incx,
 450                                                       double *y,
 451                                                       int incy);
 452
 453 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCaxpy_v2 (cublasHandle_t handle,
 454                                                       int n,
 455                                                       const cuComplex *alpha, /* host or device pointer */
 456                                                       const cuComplex *x,
 457                                                       int incx,
 458                                                       cuComplex *y,
 459                                                       int incy);
 460
 461 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZaxpy_v2 (cublasHandle_t handle,
 462                                                       int n,
 463                                                       const cuDoubleComplex *alpha, /* host or device pointer */
 464                                                       const cuDoubleComplex *x,
 465                                                       int incx,
 466                                                       cuDoubleComplex *y,
 467                                                       int incy);
 468
 469 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasScopy_v2 (cublasHandle_t handle,
 470                                                       int n,
 471                                                       const float *x,
 472                                                       int incx,
 473                                                       float *y,
 474                                                       int incy);
 475
 476 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDcopy_v2 (cublasHandle_t handle,
 477                                                       int n,
 478                                                       const double *x,
 479                                                       int incx,
 480                                                       double *y,
 481                                                       int incy);
 482
 483 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCcopy_v2 (cublasHandle_t handle,
 484                                                       int n,
 485                                                       const cuComplex *x,
 486                                                       int incx,
 487                                                       cuComplex *y,
 488                                                       int incy);
 489
 490 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZcopy_v2 (cublasHandle_t handle,
 491                                                       int n,
 492                                                       const cuDoubleComplex *x,
 493                                                       int incx,
 494                                                       cuDoubleComplex *y,
 495                                                       int incy);
 496
 497 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSswap_v2 (cublasHandle_t handle,
 498                                                       int n,
 499                                                       float *x,
 500                                                       int incx,
 501                                                       float *y,
 502                                                       int incy);
 503
 504 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDswap_v2 (cublasHandle_t handle,
 505                                                       int n,
 506                                                       double *x,
 507                                                       int incx,
 508                                                       double *y,
 509                                                       int incy);
 510
 511 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCswap_v2 (cublasHandle_t handle,
 512                                                       int n,
 513                                                       cuComplex *x,
 514                                                       int incx,
 515                                                       cuComplex *y,
 516                                                       int incy);
 517
 518 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZswap_v2 (cublasHandle_t handle,
 519                                                       int n,
 520                                                       cuDoubleComplex *x,
 521                                                       int incx,
 522                                                       cuDoubleComplex *y,
 523                                                       int incy);
 524
 525 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasIsamax_v2(cublasHandle_t handle,
 526                                                       int n,
 527                                                       const float *x,
 528                                                       int incx,
 529                                                       int *result); /* host or device pointer */
 530
 531 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasIdamax_v2(cublasHandle_t handle,
 532                                                       int n,
 533                                                       const double *x,
 534                                                       int incx,
 535                                                       int *result); /* host or device pointer */
 536
 537 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasIcamax_v2(cublasHandle_t handle,
 538                                                       int n,
 539                                                       const cuComplex *x,
 540                                                       int incx,
 541                                                       int *result); /* host or device pointer */
 542
 543 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasIzamax_v2(cublasHandle_t handle,
 544                                                       int n,
 545                                                       const cuDoubleComplex *x,
 546                                                       int incx,
 547                                                       int *result); /* host or device pointer */
 548
 549 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasIsamin_v2(cublasHandle_t handle,
 550                                                       int n,
 551                                                       const float *x,
 552                                                       int incx,
 553                                                       int *result); /* host or device pointer */
 554
 555 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasIdamin_v2(cublasHandle_t handle,
 556                                                       int n,
 557                                                       const double *x,
 558                                                       int incx,
 559                                                       int *result); /* host or device pointer */
 560
 561 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasIcamin_v2(cublasHandle_t handle,
 562                                                       int n,
 563                                                       const cuComplex *x,
 564                                                       int incx,
 565                                                       int *result); /* host or device pointer */
 566
 567 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasIzamin_v2(cublasHandle_t handle,
 568                                                       int n,
 569                                                       const cuDoubleComplex *x,
 570                                                       int incx,
 571                                                       int *result); /* host or device pointer */
 572
 573 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSasum_v2(cublasHandle_t handle,
 574                                                      int n,
 575                                                      const float *x,
 576                                                      int incx,
 577                                                      float *result); /* host or device pointer */
 578
 579 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDasum_v2(cublasHandle_t handle,
 580                                                      int n,
 581                                                      const double *x,
 582                                                      int incx,
 583                                                      double *result); /* host or device pointer */
 584
 585 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasScasum_v2(cublasHandle_t handle,
 586                                                       int n,
 587                                                       const cuComplex *x,
 588                                                       int incx,
 589                                                       float *result); /* host or device pointer */
 590
 591 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDzasum_v2(cublasHandle_t handle,
 592                                                       int n,
 593                                                       const cuDoubleComplex *x,
 594                                                       int incx,
 595                                                       double *result); /* host or device pointer */
 596
 597 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSrot_v2 (cublasHandle_t handle,
 598                                                      int n,
 599                                                      float *x,
 600                                                      int incx,
 601                                                      float *y,
 602                                                      int incy,
 603                                                      const float *c,  /* host or device pointer */
 604                                                      const float *s); /* host or device pointer */
 605
 606 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDrot_v2 (cublasHandle_t handle,
 607                                                      int n,
 608                                                      double *x,
 609                                                      int incx,
 610                                                      double *y,
 611                                                      int incy,
 612                                                      const double *c,  /* host or device pointer */
 613                                                      const double *s); /* host or device pointer */
 614
 615 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCrot_v2 (cublasHandle_t handle,
 616                                                      int n,
 617                                                      cuComplex *x,
 618                                                      int incx,
 619                                                      cuComplex *y,
 620                                                      int incy,
 621                                                      const float *c,      /* host or device pointer */
 622                                                      const cuComplex *s); /* host or device pointer */
 623
 624 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCsrot_v2(cublasHandle_t handle,
 625                                                      int n,
 626                                                      cuComplex *x,
 627                                                      int incx,
 628                                                      cuComplex *y,
 629                                                      int incy,
 630                                                      const float *c,  /* host or device pointer */
 631                                                      const float *s); /* host or device pointer */
 632
 633 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZrot_v2 (cublasHandle_t handle,
 634                                                      int n,
 635                                                      cuDoubleComplex *x,
 636                                                      int incx,
 637                                                      cuDoubleComplex *y,
 638                                                      int incy,
 639                                                      const double *c,            /* host or device pointer */
 640                                                      const cuDoubleComplex *s);  /* host or device pointer */
 641
 642 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZdrot_v2(cublasHandle_t handle,
 643                                                      int n,
 644                                                      cuDoubleComplex *x,
 645                                                      int incx,
 646                                                      cuDoubleComplex *y,
 647                                                      int incy,
 648                                                      const double *c,  /* host or device pointer */
 649                                                      const double *s); /* host or device pointer */
 650
 651 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSrotg_v2(cublasHandle_t handle,
 652                                                      float *a,   /* host or device pointer */
 653                                                      float *b,   /* host or device pointer */
 654                                                      float *c,   /* host or device pointer */
 655                                                      float *s);  /* host or device pointer */
 656
 657 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDrotg_v2(cublasHandle_t handle,
 658                                                      double *a,  /* host or device pointer */
 659                                                      double *b,  /* host or device pointer */
 660                                                      double *c,  /* host or device pointer */
 661                                                      double *s); /* host or device pointer */
 662
 663 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCrotg_v2(cublasHandle_t handle,
 664                                                      cuComplex *a,  /* host or device pointer */
 665                                                      cuComplex *b,  /* host or device pointer */
 666                                                      float *c,      /* host or device pointer */
 667                                                      cuComplex *s); /* host or device pointer */
 668
 669 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZrotg_v2(cublasHandle_t handle,
 670                                                      cuDoubleComplex *a,  /* host or device pointer */
 671                                                      cuDoubleComplex *b,  /* host or device pointer */
 672                                                      double *c,           /* host or device pointer */
 673                                                      cuDoubleComplex *s); /* host or device pointer */
 674
 675 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSrotm_v2(cublasHandle_t handle,
 676                                                      int n,
 677                                                      float *x,
 678                                                      int incx,
 679                                                      float *y,
 680                                                      int incy,
 681                                                      const float* param);  /* host or device pointer */
 682
 683 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDrotm_v2(cublasHandle_t handle,
 684                                                      int n,
 685                                                      double *x,
 686                                                      int incx,
 687                                                      double *y,
 688                                                      int incy,
 689                                                      const double* param);  /* host or device pointer */
 690
 691 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSrotmg_v2(cublasHandle_t handle,
 692                                                       float *d1,        /* host or device pointer */
 693                                                       float *d2,        /* host or device pointer */
 694                                                       float *x1,        /* host or device pointer */
 695                                                       const float *y1,  /* host or device pointer */
 696                                                       float *param);    /* host or device pointer */
 697
 698 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDrotmg_v2(cublasHandle_t handle,
 699                                                       double *d1,        /* host or device pointer */
 700                                                       double *d2,        /* host or device pointer */
 701                                                       double *x1,        /* host or device pointer */
 702                                                       const double *y1,  /* host or device pointer */
 703                                                       double *param);    /* host or device pointer */
 704
 705 /* --------------- CUBLAS BLAS2 functions  ---------------- */
 706
 707 /* GEMV */
 708 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSgemv_v2 (cublasHandle_t handle,
 709                                                       cublasOperation_t trans,
 710                                                       int m,
 711                                                       int n,
 712                                                       const float *alpha, /* host or device pointer */
 713                                                       const float *A,
 714                                                       int lda,
 715                                                       const float *x,
 716                                                       int incx,
 717                                                       const float *beta,  /* host or device pointer */
 718                                                       float *y,
 719                                                       int incy);
 720
 721 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDgemv_v2 (cublasHandle_t handle,
 722                                                       cublasOperation_t trans,
 723                                                       int m,
 724                                                       int n,
 725                                                       const double *alpha, /* host or device pointer */
 726                                                       const double *A,
 727                                                       int lda,
 728                                                       const double *x,
 729                                                       int incx,
 730                                                       const double *beta, /* host or device pointer */
 731                                                       double *y,
 732                                                       int incy);
 733
 734 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCgemv_v2 (cublasHandle_t handle,
 735                                                       cublasOperation_t trans,
 736                                                       int m,
 737                                                       int n,
 738                                                       const cuComplex *alpha, /* host or device pointer */
 739                                                       const cuComplex *A,
 740                                                       int lda,
 741                                                       const cuComplex *x,
 742                                                       int incx,
 743                                                       const cuComplex *beta, /* host or device pointer */
 744                                                       cuComplex *y,
 745                                                       int incy);
 746
 747 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZgemv_v2 (cublasHandle_t handle,
 748                                                       cublasOperation_t trans,
 749                                                       int m,
 750                                                       int n,
 751                                                       const cuDoubleComplex *alpha, /* host or device pointer */
 752                                                       const cuDoubleComplex *A,
 753                                                       int lda,
 754                                                       const cuDoubleComplex *x,
 755                                                       int incx,
 756                                                       const cuDoubleComplex *beta, /* host or device pointer */
 757                                                       cuDoubleComplex *y,
 758                                                       int incy);
 759 /* GBMV */
 760 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSgbmv_v2 (cublasHandle_t handle,
 761                                                       cublasOperation_t trans,
 762                                                       int m,
 763                                                       int n,
 764                                                       int kl,
 765                                                       int ku,
 766                                                       const float *alpha, /* host or device pointer */
 767                                                       const float *A,
 768                                                       int lda,
 769                                                       const float *x,
 770                                                       int incx,
 771                                                       const float *beta, /* host or device pointer */
 772                                                       float *y,
 773                                                       int incy);
 774
 775 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDgbmv_v2 (cublasHandle_t handle,
 776                                                       cublasOperation_t trans,
 777                                                       int m,
 778                                                       int n,
 779                                                       int kl,
 780                                                       int ku,
 781                                                       const double *alpha, /* host or device pointer */
 782                                                       const double *A,
 783                                                       int lda,
 784                                                       const double *x,
 785                                                       int incx,
 786                                                       const double *beta, /* host or device pointer */
 787                                                       double *y,
 788                                                       int incy);
 789
 790 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCgbmv_v2 (cublasHandle_t handle,
 791                                                       cublasOperation_t trans,
 792                                                       int m,
 793                                                       int n,
 794                                                       int kl,
 795                                                       int ku,
 796                                                       const cuComplex *alpha, /* host or device pointer */
 797                                                       const cuComplex *A,
 798                                                       int lda,
 799                                                       const cuComplex *x,
 800                                                       int incx,
 801                                                       const cuComplex *beta, /* host or device pointer */
 802                                                       cuComplex *y,
 803                                                       int incy);
 804
 805 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZgbmv_v2 (cublasHandle_t handle,
 806                                                       cublasOperation_t trans,
 807                                                       int m,
 808                                                       int n,
 809                                                       int kl,
 810                                                       int ku,
 811                                                       const cuDoubleComplex *alpha, /* host or device pointer */
 812                                                       const cuDoubleComplex *A,
 813                                                       int lda,
 814                                                       const cuDoubleComplex *x,
 815                                                       int incx,
 816                                                       const cuDoubleComplex *beta, /* host or device pointer */
 817                                                       cuDoubleComplex *y,
 818                                                       int incy);
 819
 820 /* TRMV */
 821 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasStrmv_v2 (cublasHandle_t handle,
 822                                                       cublasFillMode_t uplo,
 823                                                       cublasOperation_t trans,
 824                                                       cublasDiagType_t diag,
 825                                                       int n,
 826                                                       const float *A,
 827                                                       int lda,
 828                                                       float *x,
 829                                                       int incx);
 830
 831 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDtrmv_v2 (cublasHandle_t handle,
 832                                                       cublasFillMode_t uplo,
 833                                                       cublasOperation_t trans,
 834                                                       cublasDiagType_t diag,
 835                                                       int n,
 836                                                       const double *A,
 837                                                       int lda,
 838                                                       double *x,
 839                                                       int incx);
 840
 841 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCtrmv_v2 (cublasHandle_t handle,
 842                                                       cublasFillMode_t uplo,
 843                                                       cublasOperation_t trans,
 844                                                       cublasDiagType_t diag,
 845                                                       int n,
 846                                                       const cuComplex *A,
 847                                                       int lda,
 848                                                       cuComplex *x,
 849                                                       int incx);
 850
 851 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZtrmv_v2 (cublasHandle_t handle,
 852                                                       cublasFillMode_t uplo,
 853                                                       cublasOperation_t trans,
 854                                                       cublasDiagType_t diag,
 855                                                       int n,
 856                                                       const cuDoubleComplex *A,
 857                                                       int lda,
 858                                                       cuDoubleComplex *x,
 859                                                       int incx);
 860
 861 /* TBMV */
 862 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasStbmv_v2 (cublasHandle_t handle,
 863                                                       cublasFillMode_t uplo,
 864                                                       cublasOperation_t trans,
 865                                                       cublasDiagType_t diag,
 866                                                       int n,
 867                                                       int k,
 868                                                       const float *A,
 869                                                       int lda,
 870                                                       float *x,
 871                                                       int incx);
 872
 873 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDtbmv_v2 (cublasHandle_t handle,
 874                                                       cublasFillMode_t uplo,
 875                                                       cublasOperation_t trans,
 876                                                       cublasDiagType_t diag,
 877                                                       int n,
 878                                                       int k,
 879                                                       const double *A,
 880                                                       int lda,
 881                                                       double *x,
 882                                                       int incx);
 883
 884 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCtbmv_v2 (cublasHandle_t handle,
 885                                                       cublasFillMode_t uplo,
 886                                                       cublasOperation_t trans,
 887                                                       cublasDiagType_t diag,
 888                                                       int n,
 889                                                       int k,
 890                                                       const cuComplex *A,
 891                                                       int lda,
 892                                                       cuComplex *x,
 893                                                       int incx);
 894
 895 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZtbmv_v2 (cublasHandle_t handle,
 896                                                       cublasFillMode_t uplo,
 897                                                       cublasOperation_t trans,
 898                                                       cublasDiagType_t diag,
 899                                                       int n,
 900                                                       int k,
 901                                                       const cuDoubleComplex *A,
 902                                                       int lda,
 903                                                       cuDoubleComplex *x,
 904                                                       int incx);
 905
 906 /* TPMV */
 907 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasStpmv_v2 (cublasHandle_t handle,
 908                                                       cublasFillMode_t uplo,
 909                                                       cublasOperation_t trans,
 910                                                       cublasDiagType_t diag,
 911                                                       int n,
 912                                                       const float *AP,
 913                                                       float *x,
 914                                                       int incx);
 915
 916 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDtpmv_v2 (cublasHandle_t handle,
 917                                                       cublasFillMode_t uplo,
 918                                                       cublasOperation_t trans,
 919                                                       cublasDiagType_t diag,
 920                                                       int n,
 921                                                       const double *AP,
 922                                                       double *x,
 923                                                       int incx);
 924
 925 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCtpmv_v2 (cublasHandle_t handle,
 926                                                       cublasFillMode_t uplo,
 927                                                       cublasOperation_t trans,
 928                                                       cublasDiagType_t diag,
 929                                                       int n,
 930                                                       const cuComplex *AP,
 931                                                       cuComplex *x,
 932                                                       int incx);
 933
 934 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZtpmv_v2 (cublasHandle_t handle,
 935                                                       cublasFillMode_t uplo,
 936                                                       cublasOperation_t trans,
 937                                                       cublasDiagType_t diag,
 938                                                       int n,
 939                                                       const cuDoubleComplex *AP,
 940                                                       cuDoubleComplex *x,
 941                                                       int incx);
 942
 943 /* TRSV */
 944 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasStrsv_v2 (cublasHandle_t handle,
 945                                                       cublasFillMode_t uplo,
 946                                                       cublasOperation_t trans,
 947                                                       cublasDiagType_t diag,
 948                                                       int n,
 949                                                       const float *A,
 950                                                       int lda,
 951                                                       float *x,
 952                                                       int incx);
 953
 954 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDtrsv_v2 (cublasHandle_t handle,
 955                                                       cublasFillMode_t uplo,
 956                                                       cublasOperation_t trans,
 957                                                       cublasDiagType_t diag,
 958                                                       int n,
 959                                                       const double *A,
 960                                                       int lda,
 961                                                       double *x,
 962                                                       int incx);
 963
 964 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCtrsv_v2 (cublasHandle_t handle,
 965                                                       cublasFillMode_t uplo,
 966                                                       cublasOperation_t trans,
 967                                                       cublasDiagType_t diag,
 968                                                       int n,
 969                                                       const cuComplex *A,
 970                                                       int lda,
 971                                                       cuComplex *x,
 972                                                       int incx);
 973
 974 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZtrsv_v2 (cublasHandle_t handle,
 975                                                       cublasFillMode_t uplo,
 976                                                       cublasOperation_t trans,
 977                                                       cublasDiagType_t diag,
 978                                                       int n,
 979                                                       const cuDoubleComplex *A,
 980                                                       int lda,
 981                                                       cuDoubleComplex *x,
 982                                                       int incx);
 983
 984 /* TPSV */
 985 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasStpsv_v2 (cublasHandle_t handle,
 986                                                       cublasFillMode_t uplo,
 987                                                       cublasOperation_t trans,
 988                                                       cublasDiagType_t diag,
 989                                                       int n,
 990                                                       const float *AP,
 991                                                       float *x,
 992                                                       int incx);
 993
 994 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDtpsv_v2 (cublasHandle_t handle,
 995                                                       cublasFillMode_t uplo,
 996                                                       cublasOperation_t trans,
 997                                                       cublasDiagType_t diag,
 998                                                       int n,
 999                                                       const double *AP,
1000                                                       double *x,
1001                                                       int incx);
1002
1003 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCtpsv_v2 (cublasHandle_t handle,
1004                                                       cublasFillMode_t uplo,
1005                                                       cublasOperation_t trans,
1006                                                       cublasDiagType_t diag,
1007                                                       int n,
1008                                                       const cuComplex *AP,
1009                                                       cuComplex *x,
1010                                                       int incx);
1011
1012 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZtpsv_v2 (cublasHandle_t handle,
1013                                                       cublasFillMode_t uplo,
1014                                                       cublasOperation_t trans,
1015                                                       cublasDiagType_t diag,
1016                                                       int n,
1017                                                       const cuDoubleComplex *AP,
1018                                                       cuDoubleComplex *x,
1019                                                       int incx);
1020 /* TBSV */
1021 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasStbsv_v2 (cublasHandle_t handle,
1022                                                       cublasFillMode_t uplo,
1023                                                       cublasOperation_t trans,
1024                                                       cublasDiagType_t diag,
1025                                                       int n,
1026                                                       int k,
1027                                                       const float *A,
1028                                                       int lda,
1029                                                       float *x,
1030                                                       int incx);
1031
1032 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDtbsv_v2 (cublasHandle_t handle,
1033                                                       cublasFillMode_t uplo,
1034                                                       cublasOperation_t trans,
1035                                                       cublasDiagType_t diag,
1036                                                       int n,
1037                                                       int k,
1038                                                       const double *A,
1039                                                       int lda,
1040                                                       double *x,
1041                                                       int incx);
1042
1043 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCtbsv_v2 (cublasHandle_t handle,
1044                                                       cublasFillMode_t uplo,
1045                                                       cublasOperation_t trans,
1046                                                       cublasDiagType_t diag,
1047                                                       int n,
1048                                                       int k,
1049                                                       const cuComplex *A,
1050                                                       int lda,
1051                                                       cuComplex *x,
1052                                                       int incx);
1053
1054 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZtbsv_v2 (cublasHandle_t handle,
1055                                                       cublasFillMode_t uplo,
1056                                                       cublasOperation_t trans,
1057                                                       cublasDiagType_t diag,
1058                                                       int n,
1059                                                       int k,
1060                                                       const cuDoubleComplex *A,
1061                                                       int lda,
1062                                                       cuDoubleComplex *x,
1063                                                       int incx);
1064
1065 /* SYMV/HEMV */
1066 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSsymv_v2 (cublasHandle_t handle,
1067                                                       cublasFillMode_t uplo,
1068                                                       int n,
1069                                                       const float *alpha, /* host or device pointer */
1070                                                       const float *A,
1071                                                       int lda,
1072                                                       const float *x,
1073                                                       int incx,
1074                                                       const float *beta, /* host or device pointer */
1075                                                       float *y,
1076                                                       int incy);
1077
1078 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDsymv_v2 (cublasHandle_t handle,
1079                                                       cublasFillMode_t uplo,
1080                                                       int n,
1081                                                       const double *alpha, /* host or device pointer */
1082                                                       const double *A,
1083                                                       int lda,
1084                                                       const double *x,
1085                                                       int incx,
1086                                                       const double *beta, /* host or device pointer */
1087                                                       double *y,
1088                                                       int incy);
1089
1090 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCsymv_v2 (cublasHandle_t handle,
1091                                                       cublasFillMode_t uplo,
1092                                                       int n,
1093                                                       const cuComplex *alpha, /* host or device pointer */
1094                                                       const cuComplex *A,
1095                                                       int lda,
1096                                                       const cuComplex *x,
1097                                                       int incx,
1098                                                       const cuComplex *beta, /* host or device pointer */
1099                                                       cuComplex *y,
1100                                                       int incy);
1101
1102 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZsymv_v2 (cublasHandle_t handle,
1103                                                       cublasFillMode_t uplo,
1104                                                       int n,
1105                                                       const cuDoubleComplex *alpha,  /* host or device pointer */
1106                                                       const cuDoubleComplex *A,
1107                                                       int lda,
1108                                                       const cuDoubleComplex *x,
1109                                                       int incx,
1110                                                       const cuDoubleComplex *beta,   /* host or device pointer */
1111                                                       cuDoubleComplex *y,
1112                                                       int incy);
1113
1114 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasChemv_v2 (cublasHandle_t handle,
1115                                                       cublasFillMode_t uplo,
1116                                                       int n,
1117                                                       const cuComplex *alpha, /* host or device pointer */
1118                                                       const cuComplex *A,
1119                                                       int lda,
1120                                                       const cuComplex *x,
1121                                                       int incx,
1122                                                       const cuComplex *beta, /* host or device pointer */
1123                                                       cuComplex *y,
1124                                                       int incy);
1125
1126 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZhemv_v2 (cublasHandle_t handle,
1127                                                       cublasFillMode_t uplo,
1128                                                       int n,
1129                                                       const cuDoubleComplex *alpha,  /* host or device pointer */
1130                                                       const cuDoubleComplex *A,
1131                                                       int lda,
1132                                                       const cuDoubleComplex *x,
1133                                                       int incx,
1134                                                       const cuDoubleComplex *beta,   /* host or device pointer */
1135                                                       cuDoubleComplex *y,
1136                                                       int incy);
1137
1138 /* SBMV/HBMV */
1139 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSsbmv_v2 (cublasHandle_t handle,
1140                                                       cublasFillMode_t uplo,
1141                                                       int n,
1142                                                       int k,
1143                                                       const float *alpha,   /* host or device pointer */
1144                                                       const float *A,
1145                                                       int lda,
1146                                                       const float *x,
1147                                                       int incx,
1148                                                       const float *beta,  /* host or device pointer */
1149                                                       float *y,
1150                                                       int incy);
1151
1152 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDsbmv_v2 (cublasHandle_t handle,
1153                                                       cublasFillMode_t uplo,
1154                                                       int n,
1155                                                       int k,
1156                                                       const double *alpha,   /* host or device pointer */
1157                                                       const double *A,
1158                                                       int lda,
1159                                                       const double *x,
1160                                                       int incx,
1161                                                       const double *beta,   /* host or device pointer */
1162                                                       double *y,
1163                                                       int incy);
1164
1165 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasChbmv_v2 (cublasHandle_t handle,
1166                                                       cublasFillMode_t uplo,
1167                                                       int n,
1168                                                       int k,
1169                                                       const cuComplex *alpha, /* host or device pointer */
1170                                                       const cuComplex *A,
1171                                                       int lda,
1172                                                       const cuComplex *x,
1173                                                       int incx,
1174                                                       const cuComplex *beta, /* host or device pointer */
1175                                                       cuComplex *y,
1176                                                       int incy);
1177
1178 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZhbmv_v2 (cublasHandle_t handle,
1179                                                       cublasFillMode_t uplo,
1180                                                       int n,
1181                                                       int k,
1182                                                       const cuDoubleComplex *alpha, /* host or device pointer */
1183                                                       const cuDoubleComplex *A,
1184                                                       int lda,
1185                                                       const cuDoubleComplex *x,
1186                                                       int incx,
1187                                                       const cuDoubleComplex *beta, /* host or device pointer */
1188                                                       cuDoubleComplex *y,
1189                                                       int incy);
1190
1191 /* SPMV/HPMV */
1192 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSspmv_v2 (cublasHandle_t handle,
1193                                                       cublasFillMode_t uplo,
1194                                                       int n,
1195                                                       const float *alpha,  /* host or device pointer */
1196                                                       const float *AP,
1197                                                       const float *x,
1198                                                       int incx,
1199                                                       const float *beta,   /* host or device pointer */
1200                                                       float *y,
1201                                                       int incy);
1202
1203 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDspmv_v2 (cublasHandle_t handle,
1204                                                       cublasFillMode_t uplo,
1205                                                       int n,
1206                                                       const double *alpha, /* host or device pointer */
1207                                                       const double *AP,
1208                                                       const double *x,
1209                                                       int incx,
1210                                                       const double *beta,  /* host or device pointer */
1211                                                       double *y,
1212                                                       int incy);
1213
1214 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasChpmv_v2 (cublasHandle_t handle,
1215                                                       cublasFillMode_t uplo,
1216                                                       int n,
1217                                                       const cuComplex *alpha, /* host or device pointer */
1218                                                       const cuComplex *AP,
1219                                                       const cuComplex *x,
1220                                                       int incx,
1221                                                       const cuComplex *beta, /* host or device pointer */
1222                                                       cuComplex *y,
1223                                                       int incy);
1224
1225 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZhpmv_v2 (cublasHandle_t handle,
1226                                                       cublasFillMode_t uplo,
1227                                                       int n,
1228                                                       const cuDoubleComplex *alpha, /* host or device pointer */
1229                                                       const cuDoubleComplex *AP,
1230                                                       const cuDoubleComplex *x,
1231                                                       int incx,
1232                                                       const cuDoubleComplex *beta, /* host or device pointer */
1233                                                       cuDoubleComplex *y,
1234                                                       int incy);
1235
1236 /* GER */
1237 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSger_v2 (cublasHandle_t handle,
1238                                                      int m,
1239                                                      int n,
1240                                                      const float *alpha, /* host or device pointer */
1241                                                      const float *x,
1242                                                      int incx,
1243                                                      const float *y,
1244                                                      int incy,
1245                                                      float *A,
1246                                                      int lda);
1247
1248 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDger_v2 (cublasHandle_t handle,
1249                                                      int m,
1250                                                      int n,
1251                                                      const double *alpha, /* host or device pointer */
1252                                                      const double *x,
1253                                                      int incx,
1254                                                      const double *y,
1255                                                      int incy,
1256                                                      double *A,
1257                                                      int lda);
1258
1259 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCgeru_v2 (cublasHandle_t handle,
1260                                                       int m,
1261                                                       int n,
1262                                                       const cuComplex *alpha, /* host or device pointer */
1263                                                       const cuComplex *x,
1264                                                       int incx,
1265                                                       const cuComplex *y,
1266                                                       int incy,
1267                                                       cuComplex *A,
1268                                                       int lda);
1269
1270 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCgerc_v2 (cublasHandle_t handle,
1271                                                       int m,
1272                                                       int n,
1273                                                       const cuComplex *alpha, /* host or device pointer */
1274                                                       const cuComplex *x,
1275                                                       int incx,
1276                                                       const cuComplex *y,
1277                                                       int incy,
1278                                                       cuComplex *A,
1279                                                       int lda);
1280
1281 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZgeru_v2 (cublasHandle_t handle,
1282                                                       int m,
1283                                                       int n,
1284                                                       const cuDoubleComplex *alpha, /* host or device pointer */
1285                                                       const cuDoubleComplex *x,
1286                                                       int incx,
1287                                                       const cuDoubleComplex *y,
1288                                                       int incy,
1289                                                       cuDoubleComplex *A,
1290                                                       int lda);
1291
1292 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZgerc_v2 (cublasHandle_t handle,
1293                                                       int m,
1294                                                       int n,
1295                                                       const cuDoubleComplex *alpha, /* host or device pointer */
1296                                                       const cuDoubleComplex *x,
1297                                                       int incx,
1298                                                       const cuDoubleComplex *y,
1299                                                       int incy,
1300                                                       cuDoubleComplex *A,
1301                                                       int lda);
1302
1303 /* SYR/HER */
1304 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSsyr_v2 (cublasHandle_t handle,
1305                                                      cublasFillMode_t uplo,
1306                                                      int n,
1307                                                      const float *alpha, /* host or device pointer */
1308                                                      const float *x,
1309                                                      int incx,
1310                                                      float *A,
1311                                                      int lda);
1312
1313 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDsyr_v2 (cublasHandle_t handle,
1314                                                      cublasFillMode_t uplo,
1315                                                      int n,
1316                                                      const double *alpha, /* host or device pointer */
1317                                                      const double *x,
1318                                                      int incx,
1319                                                      double *A,
1320                                                      int lda);
1321
1322 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCsyr_v2 (cublasHandle_t handle,
1323                                                      cublasFillMode_t uplo,
1324                                                      int n,
1325                                                      const cuComplex *alpha, /* host or device pointer */
1326                                                      const cuComplex *x,
1327                                                      int incx,
1328                                                      cuComplex *A,
1329                                                      int lda);
1330
1331 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZsyr_v2 (cublasHandle_t handle,
1332                                                      cublasFillMode_t uplo,
1333                                                      int n,
1334                                                      const cuDoubleComplex *alpha, /* host or device pointer */
1335                                                      const cuDoubleComplex *x,
1336                                                      int incx,
1337                                                      cuDoubleComplex *A,
1338                                                      int lda);
1339
1340 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCher_v2 (cublasHandle_t handle,
1341                                                      cublasFillMode_t uplo,
1342                                                      int n,
1343                                                      const float *alpha, /* host or device pointer */
1344                                                      const cuComplex *x,
1345                                                      int incx,
1346                                                      cuComplex *A,
1347                                                      int lda);
1348
1349 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZher_v2 (cublasHandle_t handle,
1350                                                      cublasFillMode_t uplo,
1351                                                      int n,
1352                                                      const double *alpha, /* host or device pointer */
1353                                                      const cuDoubleComplex *x,
1354                                                      int incx,
1355                                                      cuDoubleComplex *A,
1356                                                      int lda);
1357
1358 /* SPR/HPR */
1359 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSspr_v2 (cublasHandle_t handle,
1360                                                      cublasFillMode_t uplo,
1361                                                      int n,
1362                                                      const float *alpha, /* host or device pointer */
1363                                                      const float *x,
1364                                                      int incx,
1365                                                      float *AP);
1366
1367 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDspr_v2 (cublasHandle_t handle,
1368                                                      cublasFillMode_t uplo,
1369                                                      int n,
1370                                                      const double *alpha, /* host or device pointer */
1371                                                      const double *x,
1372                                                      int incx,
1373                                                      double *AP);
1374
1375 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasChpr_v2 (cublasHandle_t handle,
1376                                                      cublasFillMode_t uplo,
1377                                                      int n,
1378                                                      const float *alpha, /* host or device pointer */
1379                                                      const cuComplex *x,
1380                                                      int incx,
1381                                                      cuComplex *AP);
1382
1383 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZhpr_v2 (cublasHandle_t handle,
1384                                                      cublasFillMode_t uplo,
1385                                                      int n,
1386                                                      const double *alpha, /* host or device pointer */
1387                                                      const cuDoubleComplex *x,
1388                                                      int incx,
1389                                                      cuDoubleComplex *AP);
1390
1391 /* SYR2/HER2 */
1392 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSsyr2_v2 (cublasHandle_t handle,
1393                                                       cublasFillMode_t uplo,
1394                                                       int n,
1395                                                       const float *alpha, /* host or device pointer */
1396                                                       const float *x,
1397                                                       int incx,
1398                                                       const float *y,
1399                                                       int incy,
1400                                                       float *A,
1401                                                       int lda);
1402
1403 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDsyr2_v2 (cublasHandle_t handle,
1404                                                       cublasFillMode_t uplo,
1405                                                       int n,
1406                                                       const double *alpha, /* host or device pointer */
1407                                                       const double *x,
1408                                                       int incx,
1409                                                       const double *y,
1410                                                       int incy,
1411                                                       double *A,
1412                                                       int lda);
1413
1414 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCsyr2_v2 (cublasHandle_t handle,
1415                                                       cublasFillMode_t uplo, int n,
1416                                                       const cuComplex *alpha,  /* host or device pointer */
1417                                                       const cuComplex *x,
1418                                                       int incx,
1419                                                       const cuComplex *y,
1420                                                       int incy,
1421                                                       cuComplex *A,
1422                                                       int lda);
1423
1424 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZsyr2_v2 (cublasHandle_t handle,
1425                                                       cublasFillMode_t uplo,
1426                                                       int n,
1427                                                       const cuDoubleComplex *alpha,  /* host or device pointer */
1428                                                       const cuDoubleComplex *x,
1429                                                       int incx,
1430                                                       const cuDoubleComplex *y,
1431                                                       int incy,
1432                                                       cuDoubleComplex *A,
1433                                                       int lda);
1434
1435
1436 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCher2_v2 (cublasHandle_t handle,
1437                                                       cublasFillMode_t uplo, int n,
1438                                                       const cuComplex *alpha,  /* host or device pointer */
1439                                                       const cuComplex *x,
1440                                                       int incx,
1441                                                       const cuComplex *y,
1442                                                       int incy,
1443                                                       cuComplex *A,
1444                                                       int lda);
1445
1446 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZher2_v2 (cublasHandle_t handle,
1447                                                       cublasFillMode_t uplo,
1448                                                       int n,
1449                                                       const cuDoubleComplex *alpha,  /* host or device pointer */
1450                                                       const cuDoubleComplex *x,
1451                                                       int incx,
1452                                                       const cuDoubleComplex *y,
1453                                                       int incy,
1454                                                       cuDoubleComplex *A,
1455                                                       int lda);
1456
1457 /* SPR2/HPR2 */
1458 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSspr2_v2 (cublasHandle_t handle,
1459                                                       cublasFillMode_t uplo,
1460                                                       int n,
1461                                                       const float *alpha,  /* host or device pointer */
1462                                                       const float *x,
1463                                                       int incx,
1464                                                       const float *y,
1465                                                       int incy,
1466                                                       float *AP);
1467
1468 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDspr2_v2 (cublasHandle_t handle,
1469                                                       cublasFillMode_t uplo,
1470                                                       int n,
1471                                                       const double *alpha,  /* host or device pointer */
1472                                                       const double *x,
1473                                                       int incx,
1474                                                       const double *y,
1475                                                       int incy,
1476                                                       double *AP);
1477
1478
1479 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasChpr2_v2 (cublasHandle_t handle,
1480                                                       cublasFillMode_t uplo,
1481                                                       int n,
1482                                                       const cuComplex *alpha, /* host or device pointer */
1483                                                       const cuComplex *x,
1484                                                       int incx,
1485                                                       const cuComplex *y,
1486                                                       int incy,
1487                                                       cuComplex *AP);
1488
1489 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZhpr2_v2 (cublasHandle_t handle,
1490                                                       cublasFillMode_t uplo,
1491                                                       int n,
1492                                                       const cuDoubleComplex *alpha, /* host or device pointer */
1493                                                       const cuDoubleComplex *x,
1494                                                       int incx,
1495                                                       const cuDoubleComplex *y,
1496                                                       int incy,
1497                                                       cuDoubleComplex *AP);
1498
1499 /* ---------------- CUBLAS BLAS3 functions ---------------- */
1500
1501 /* GEMM */
1502 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSgemm_v2 (cublasHandle_t handle,
1503                                                       cublasOperation_t transa,
1504                                                       cublasOperation_t transb,
1505                                                       int m,
1506                                                       int n,
1507                                                       int k,
1508                                                       const float *alpha, /* host or device pointer */
1509                                                       const float *A,
1510                                                       int lda,
1511                                                       const float *B,
1512                                                       int ldb,
1513                                                       const float *beta, /* host or device pointer */
1514                                                       float *C,
1515                                                       int ldc);
1516
1517 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDgemm_v2 (cublasHandle_t handle,
1518                                                       cublasOperation_t transa,
1519                                                       cublasOperation_t transb,
1520                                                       int m,
1521                                                       int n,
1522                                                       int k,
1523                                                       const double *alpha, /* host or device pointer */
1524                                                       const double *A,
1525                                                       int lda,
1526                                                       const double *B,
1527                                                       int ldb,
1528                                                       const double *beta, /* host or device pointer */
1529                                                       double *C,
1530                                                       int ldc);
1531
1532 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCgemm_v2 (cublasHandle_t handle,
1533                                                       cublasOperation_t transa,
1534                                                       cublasOperation_t transb,
1535                                                       int m,
1536                                                       int n,
1537                                                       int k,
1538                                                       const cuComplex *alpha, /* host or device pointer */
1539                                                       const cuComplex *A,
1540                                                       int lda,
1541                                                       const cuComplex *B,
1542                                                       int ldb,
1543                                                       const cuComplex *beta, /* host or device pointer */
1544                                                       cuComplex *C,
1545                                                       int ldc);
1546
1547 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZgemm_v2 (cublasHandle_t handle,
1548                                                       cublasOperation_t transa,
1549                                                       cublasOperation_t transb,
1550                                                       int m,
1551                                                       int n,
1552                                                       int k,
1553                                                       const cuDoubleComplex *alpha, /* host or device pointer */
1554                                                       const cuDoubleComplex *A,
1555                                                       int lda,
1556                                                       const cuDoubleComplex *B,
1557                                                       int ldb,
1558                                                       const cuDoubleComplex *beta, /* host or device pointer */
1559                                                       cuDoubleComplex *C,
1560                                                       int ldc);
1561
1562 /* SYRK */
1563 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSsyrk_v2 (cublasHandle_t handle,
1564                                                       cublasFillMode_t uplo,
1565                                                       cublasOperation_t trans,
1566                                                       int n,
1567                                                       int k,
1568                                                       const float *alpha, /* host or device pointer */
1569                                                       const float *A,
1570                                                       int lda,
1571                                                       const float *beta, /* host or device pointer */
1572                                                       float *C,
1573                                                       int ldc);
1574
1575 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDsyrk_v2 (cublasHandle_t handle,
1576                                                       cublasFillMode_t uplo,
1577                                                       cublasOperation_t trans,
1578                                                       int n,
1579                                                       int k,
1580                                                       const double *alpha,  /* host or device pointer */
1581                                                       const double *A,
1582                                                       int lda,
1583                                                       const double *beta,  /* host or device pointer */
1584                                                       double *C,
1585                                                       int ldc);
1586
1587 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCsyrk_v2 (cublasHandle_t handle,
1588                                                       cublasFillMode_t uplo,
1589                                                       cublasOperation_t trans,
1590                                                       int n,
1591                                                       int k,
1592                                                       const cuComplex *alpha, /* host or device pointer */
1593                                                       const cuComplex *A,
1594                                                       int lda,
1595                                                       const cuComplex *beta, /* host or device pointer */
1596                                                       cuComplex *C,
1597                                                       int ldc);
1598
1599 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZsyrk_v2 (cublasHandle_t handle,
1600                                                       cublasFillMode_t uplo,
1601                                                       cublasOperation_t trans,
1602                                                       int n,
1603                                                       int k,
1604                                                       const cuDoubleComplex *alpha, /* host or device pointer */
1605                                                       const cuDoubleComplex *A,
1606                                                       int lda,
1607                                                       const cuDoubleComplex *beta, /* host or device pointer */
1608                                                       cuDoubleComplex *C,
1609                                                       int ldc);
1610 /* HERK */
1611 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCherk_v2 (cublasHandle_t handle,
1612                                                       cublasFillMode_t uplo,
1613                                                       cublasOperation_t trans,
1614                                                       int n,
1615                                                       int k,
1616                                                       const float *alpha,  /* host or device pointer */
1617                                                       const cuComplex *A,
1618                                                       int lda,
1619                                                       const float *beta,   /* host or device pointer */
1620                                                       cuComplex *C,
1621                                                       int ldc);
1622
1623 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZherk_v2 (cublasHandle_t handle,
1624                                                       cublasFillMode_t uplo,
1625                                                       cublasOperation_t trans,
1626                                                       int n,
1627                                                       int k,
1628                                                       const double *alpha,  /* host or device pointer */
1629                                                       const cuDoubleComplex *A,
1630                                                       int lda,
1631                                                       const double *beta,  /* host or device pointer */
1632                                                       cuDoubleComplex *C,
1633                                                       int ldc);
1634
1635 /* SYR2K */
1636 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSsyr2k_v2 (cublasHandle_t handle,
1637                                                        cublasFillMode_t uplo,
1638                                                        cublasOperation_t trans,
1639                                                        int n,
1640                                                        int k,
1641                                                        const float *alpha, /* host or device pointer */
1642                                                        const float *A,
1643                                                        int lda,
1644                                                        const float *B,
1645                                                        int ldb,
1646                                                        const float *beta, /* host or device pointer */
1647                                                        float *C,
1648                                                        int ldc);
1649
1650 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDsyr2k_v2 (cublasHandle_t handle,
1651                                                        cublasFillMode_t uplo,
1652                                                        cublasOperation_t trans,
1653                                                        int n,
1654                                                        int k,
1655                                                        const double *alpha, /* host or device pointer */
1656                                                        const double *A,
1657                                                        int lda,
1658                                                        const double *B,
1659                                                        int ldb,
1660                                                        const double *beta, /* host or device pointer */
1661                                                        double *C,
1662                                                        int ldc);
1663
1664 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCsyr2k_v2 (cublasHandle_t handle,
1665                                                        cublasFillMode_t uplo,
1666                                                        cublasOperation_t trans,
1667                                                        int n,
1668                                                        int k,
1669                                                        const cuComplex *alpha, /* host or device pointer */
1670                                                        const cuComplex *A,
1671                                                        int lda,
1672                                                        const cuComplex *B,
1673                                                        int ldb,
1674                                                        const cuComplex *beta, /* host or device pointer */
1675                                                        cuComplex *C,
1676                                                        int ldc);
1677
1678 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZsyr2k_v2 (cublasHandle_t handle,
1679                                                        cublasFillMode_t uplo,
1680                                                        cublasOperation_t trans,
1681                                                        int n,
1682                                                        int k,
1683                                                        const cuDoubleComplex *alpha,  /* host or device pointer */
1684                                                        const cuDoubleComplex *A,
1685                                                        int lda,
1686                                                        const cuDoubleComplex *B,
1687                                                        int ldb,
1688                                                        const cuDoubleComplex *beta,  /* host or device pointer */
1689                                                        cuDoubleComplex *C,
1690                                                        int ldc);
1691 /* HER2K */
1692 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCher2k_v2 (cublasHandle_t handle,
1693                                                        cublasFillMode_t uplo,
1694                                                        cublasOperation_t trans,
1695                                                        int n,
1696                                                        int k,
1697                                                        const cuComplex *alpha, /* host or device pointer */
1698                                                        const cuComplex *A,
1699                                                        int lda,
1700                                                        const cuComplex *B,
1701                                                        int ldb,
1702                                                        const float *beta,   /* host or device pointer */
1703                                                        cuComplex *C,
1704                                                        int ldc);
1705
1706 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZher2k_v2 (cublasHandle_t handle,
1707                                                        cublasFillMode_t uplo,
1708                                                        cublasOperation_t trans,
1709                                                        int n,
1710                                                        int k,
1711                                                        const cuDoubleComplex *alpha, /* host or device pointer */
1712                                                        const cuDoubleComplex *A,
1713                                                        int lda,
1714                                                        const cuDoubleComplex *B,
1715                                                        int ldb,
1716                                                        const double *beta, /* host or device pointer */
1717                                                        cuDoubleComplex *C,
1718                                                        int ldc);
1719 /* SYRKX : eXtended SYRK*/
1720 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSsyrkx (cublasHandle_t handle,
1721                                                     cublasFillMode_t uplo,
1722                                                     cublasOperation_t trans,
1723                                                     int n,
1724                                                     int k,
1725                                                     const float *alpha, /* host or device pointer */
1726                                                     const float *A,
1727                                                     int lda,
1728                                                     const float *B,
1729                                                     int ldb,
1730                                                     const float *beta, /* host or device pointer */
1731                                                     float *C,
1732                                                     int ldc);
1733
1734 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDsyrkx (cublasHandle_t handle,
1735                                                     cublasFillMode_t uplo,
1736                                                     cublasOperation_t trans,
1737                                                     int n,
1738                                                     int k,
1739                                                     const double *alpha, /* host or device pointer */
1740                                                     const double *A,
1741                                                     int lda,
1742                                                     const double *B,
1743                                                     int ldb,
1744                                                     const double *beta, /* host or device pointer */
1745                                                     double *C,
1746                                                     int ldc);
1747
1748 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCsyrkx (cublasHandle_t handle,
1749                                                     cublasFillMode_t uplo,
1750                                                     cublasOperation_t trans,
1751                                                     int n,
1752                                                     int k,
1753                                                     const cuComplex *alpha, /* host or device pointer */
1754                                                     const cuComplex *A,
1755                                                     int lda,
1756                                                     const cuComplex *B,
1757                                                     int ldb,
1758                                                     const cuComplex *beta, /* host or device pointer */
1759                                                     cuComplex *C,
1760                                                     int ldc);
1761
1762 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZsyrkx (cublasHandle_t handle,
1763                                                     cublasFillMode_t uplo,
1764                                                     cublasOperation_t trans,
1765                                                     int n,
1766                                                     int k,
1767                                                     const cuDoubleComplex *alpha, /* host or device pointer */
1768                                                     const cuDoubleComplex *A,
1769                                                     int lda,
1770                                                     const cuDoubleComplex *B,
1771                                                     int ldb,
1772                                                     const cuDoubleComplex *beta, /* host or device pointer */
1773                                                     cuDoubleComplex *C,
1774                                                     int ldc);
1775 /* HERKX : eXtended HERK */
1776 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCherkx (cublasHandle_t handle,
1777                                                     cublasFillMode_t uplo,
1778                                                     cublasOperation_t trans,
1779                                                     int n,
1780                                                     int k,
1781                                                     const cuComplex *alpha, /* host or device pointer */
1782                                                     const cuComplex *A,
1783                                                     int lda,
1784                                                     const cuComplex *B,
1785                                                     int ldb,
1786                                                     const float *beta, /* host or device pointer */
1787                                                     cuComplex *C,
1788                                                     int ldc);
1789
1790 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZherkx (cublasHandle_t handle,
1791                                                     cublasFillMode_t uplo,
1792                                                     cublasOperation_t trans,
1793                                                     int n,
1794                                                     int k,
1795                                                     const cuDoubleComplex *alpha, /* host or device pointer */
1796                                                     const cuDoubleComplex *A,
1797                                                     int lda,
1798                                                     const cuDoubleComplex *B,
1799                                                     int ldb,
1800                                                     const double *beta, /* host or device pointer */
1801                                                     cuDoubleComplex *C,
1802                                                     int ldc);
1803 /* SYMM */
1804 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSsymm_v2 (cublasHandle_t handle,
1805                                                       cublasSideMode_t side,
1806                                                       cublasFillMode_t uplo,
1807                                                       int m,
1808                                                       int n,
1809                                                       const float *alpha, /* host or device pointer */
1810                                                       const float *A,
1811                                                       int lda,
1812                                                       const float *B,
1813                                                       int ldb,
1814                                                       const float *beta, /* host or device pointer */
1815                                                       float *C,
1816                                                       int ldc);
1817
1818 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDsymm_v2 (cublasHandle_t handle,
1819                                                       cublasSideMode_t side,
1820                                                       cublasFillMode_t uplo,
1821                                                       int m,
1822                                                       int n,
1823                                                       const double *alpha, /* host or device pointer */
1824                                                       const double *A,
1825                                                       int lda,
1826                                                       const double *B,
1827                                                       int ldb,
1828                                                       const double *beta, /* host or device pointer */
1829                                                       double *C,
1830                                                       int ldc);
1831
1832 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCsymm_v2 (cublasHandle_t handle,
1833                                                       cublasSideMode_t side,
1834                                                       cublasFillMode_t uplo,
1835                                                       int m,
1836                                                       int n,
1837                                                       const cuComplex *alpha, /* host or device pointer */
1838                                                       const cuComplex *A,
1839                                                       int lda,
1840                                                       const cuComplex *B,
1841                                                       int ldb,
1842                                                       const cuComplex *beta, /* host or device pointer */
1843                                                       cuComplex *C,
1844                                                       int ldc);
1845
1846 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZsymm_v2 (cublasHandle_t handle,
1847                                                       cublasSideMode_t side,
1848                                                       cublasFillMode_t uplo,
1849                                                       int m,
1850                                                       int n,
1851                                                       const cuDoubleComplex *alpha, /* host or device pointer */
1852                                                       const cuDoubleComplex *A,
1853                                                       int lda,
1854                                                       const cuDoubleComplex *B,
1855                                                       int ldb,
1856                                                       const cuDoubleComplex *beta, /* host or device pointer */
1857                                                       cuDoubleComplex *C,
1858                                                       int ldc);
1859
1860 /* HEMM */
1861 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasChemm_v2 (cublasHandle_t handle,
1862                                                       cublasSideMode_t side,
1863                                                       cublasFillMode_t uplo,
1864                                                       int m,
1865                                                       int n,
1866                                                       const cuComplex *alpha, /* host or device pointer */
1867                                                       const cuComplex *A,
1868                                                       int lda,
1869                                                       const cuComplex *B,
1870                                                       int ldb,
1871                                                       const cuComplex *beta, /* host or device pointer */
1872                                                       cuComplex *C,
1873                                                       int ldc);
1874
1875 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZhemm_v2 (cublasHandle_t handle,
1876                                                       cublasSideMode_t side,
1877                                                       cublasFillMode_t uplo,
1878                                                       int m,
1879                                                       int n,
1880                                                       const cuDoubleComplex *alpha, /* host or device pointer */
1881                                                       const cuDoubleComplex *A,
1882                                                       int lda,
1883                                                       const cuDoubleComplex *B,
1884                                                       int ldb,
1885                                                       const cuDoubleComplex *beta, /* host or device pointer */
1886                                                       cuDoubleComplex *C,
1887                                                       int ldc);
1888
1889 /* TRSM */
1890 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasStrsm_v2 (cublasHandle_t handle,
1891                                                       cublasSideMode_t side,
1892                                                       cublasFillMode_t uplo,
1893                                                       cublasOperation_t trans,
1894                                                       cublasDiagType_t diag,
1895                                                       int m,
1896                                                       int n,
1897                                                       const float *alpha, /* host or device pointer */
1898                                                       const float *A,
1899                                                       int lda,
1900                                                       float *B,
1901                                                       int ldb);
1902
1903
1904 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDtrsm_v2 (cublasHandle_t handle,
1905                                                       cublasSideMode_t side,
1906                                                       cublasFillMode_t uplo,
1907                                                       cublasOperation_t trans,
1908                                                       cublasDiagType_t diag,
1909                                                       int m,
1910                                                       int n,
1911                                                       const double *alpha, /* host or device pointer */
1912                                                       const double *A,
1913                                                       int lda,
1914                                                       double *B,
1915                                                       int ldb);
1916
1917 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCtrsm_v2(cublasHandle_t handle,
1918                                                      cublasSideMode_t side,
1919                                                      cublasFillMode_t uplo,
1920                                                      cublasOperation_t trans,
1921                                                      cublasDiagType_t diag,
1922                                                      int m,
1923                                                      int n,
1924                                                      const cuComplex *alpha, /* host or device pointer */
1925                                                      const cuComplex *A,
1926                                                      int lda,
1927                                                      cuComplex *B,
1928                                                      int ldb);
1929
1930 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZtrsm_v2(cublasHandle_t handle,
1931                                                      cublasSideMode_t side,
1932                                                      cublasFillMode_t uplo,
1933                                                      cublasOperation_t trans,
1934                                                      cublasDiagType_t diag,
1935                                                      int m,
1936                                                      int n,
1937                                                      const cuDoubleComplex *alpha, /* host or device pointer */
1938                                                      const cuDoubleComplex *A,
1939                                                      int lda,
1940                                                      cuDoubleComplex *B,
1941                                                      int ldb);
1942
1943  /* TRMM */
1944 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasStrmm_v2 (cublasHandle_t handle,
1945                                                       cublasSideMode_t side,
1946                                                       cublasFillMode_t uplo,
1947                                                       cublasOperation_t trans,
1948                                                       cublasDiagType_t diag,
1949                                                       int m,
1950                                                       int n,
1951                                                       const float *alpha, /* host or device pointer */
1952                                                       const float *A,
1953                                                       int lda,
1954                                                       const float *B,
1955                                                       int ldb,
1956                                                       float *C,
1957                                                       int ldc);
1958
1959 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDtrmm_v2 (cublasHandle_t handle,
1960                                                       cublasSideMode_t side,
1961                                                       cublasFillMode_t uplo,
1962                                                       cublasOperation_t trans,
1963                                                       cublasDiagType_t diag,
1964                                                       int m,
1965                                                       int n,
1966                                                       const double *alpha, /* host or device pointer */
1967                                                       const double *A,
1968                                                       int lda,
1969                                                       const double *B,
1970                                                       int ldb,
1971                                                       double *C,
1972                                                       int ldc);
1973
1974 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCtrmm_v2(cublasHandle_t handle,
1975                                                      cublasSideMode_t side,
1976                                                      cublasFillMode_t uplo,
1977                                                      cublasOperation_t trans,
1978                                                      cublasDiagType_t diag,
1979                                                      int m,
1980                                                      int n,
1981                                                      const cuComplex *alpha, /* host or device pointer */
1982                                                      const cuComplex *A,
1983                                                      int lda,
1984                                                      const cuComplex *B,
1985                                                      int ldb,
1986                                                      cuComplex *C,
1987                                                      int ldc);
1988
1989 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZtrmm_v2(cublasHandle_t handle, cublasSideMode_t side,
1990                                                      cublasFillMode_t uplo,
1991                                                      cublasOperation_t trans,
1992                                                      cublasDiagType_t diag,
1993                                                      int m,
1994                                                      int n,
1995                                                      const cuDoubleComplex *alpha, /* host or device pointer */
1996                                                      const cuDoubleComplex *A,
1997                                                      int lda,
1998                                                      const cuDoubleComplex *B,
1999                                                      int ldb,
2000                                                      cuDoubleComplex *C,
2001                                                      int ldc);
2002 /* BATCH GEMM */
2003 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSgemmBatched (cublasHandle_t handle,
2004                                                           cublasOperation_t transa,
2005                                                           cublasOperation_t transb,
2006                                                           int m,
2007                                                           int n,
2008                                                           int k,
2009                                                           const float *alpha,  /* host or device pointer */
2010                                                           const float *Aarray[],
2011                                                           int lda,
2012                                                           const float *Barray[],
2013                                                           int ldb,
2014                                                           const float *beta,   /* host or device pointer */
2015                                                           float *Carray[],
2016                                                           int ldc,
2017                                                           int batchCount);
2018
2019 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDgemmBatched (cublasHandle_t handle,
2020                                                           cublasOperation_t transa,
2021                                                           cublasOperation_t transb,
2022                                                           int m,
2023                                                           int n,
2024                                                           int k,
2025                                                           const double *alpha,  /* host or device pointer */
2026                                                           const double *Aarray[],
2027                                                           int lda,
2028                                                           const double *Barray[],
2029                                                           int ldb,
2030                                                           const double *beta,  /* host or device pointer */
2031                                                           double *Carray[],
2032                                                           int ldc,
2033                                                           int batchCount);
2034
2035 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCgemmBatched (cublasHandle_t handle,
2036                                                           cublasOperation_t transa,
2037                                                           cublasOperation_t transb,
2038                                                           int m,
2039                                                           int n,
2040                                                           int k,
2041                                                           const cuComplex *alpha, /* host or device pointer */
2042                                                           const cuComplex *Aarray[],
2043                                                           int lda,
2044                                                           const cuComplex *Barray[],
2045                                                           int ldb,
2046                                                           const cuComplex *beta, /* host or device pointer */
2047                                                           cuComplex *Carray[],
2048                                                           int ldc,
2049                                                           int batchCount);
2050
2051 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZgemmBatched (cublasHandle_t handle,
2052                                                           cublasOperation_t transa,
2053                                                           cublasOperation_t transb,
2054                                                           int m,
2055                                                           int n,
2056                                                           int k,
2057                                                           const cuDoubleComplex *alpha, /* host or device pointer */
2058                                                           const cuDoubleComplex *Aarray[],
2059                                                           int lda,
2060                                                           const cuDoubleComplex *Barray[],
2061                                                           int ldb,
2062                                                           const cuDoubleComplex *beta, /* host or device pointer */
2063                                                           cuDoubleComplex *Carray[],
2064                                                           int ldc,
2065                                                           int batchCount);
2066
2067 /* ---------------- CUBLAS BLAS-like extension ---------------- */
2068 /* GEAM */
2069 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSgeam(cublasHandle_t handle,
2070                                                   cublasOperation_t transa,
2071                                                   cublasOperation_t transb,
2072                                                   int m,
2073                                                   int n,
2074                                                   const float *alpha, /* host or device pointer */
2075                                                   const float *A,
2076                                                   int lda,
2077                                                   const float *beta , /* host or device pointer */
2078                                                   const float *B,
2079                                                   int ldb,
2080                                                   float *C,
2081                                                   int ldc);
2082
2083 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDgeam(cublasHandle_t handle,
2084                                                   cublasOperation_t transa,
2085                                                   cublasOperation_t transb,
2086                                                   int m,
2087                                                   int n,
2088                                                   const double *alpha, /* host or device pointer */
2089                                                   const double *A,
2090                                                   int lda,
2091                                                   const double *beta, /* host or device pointer */
2092                                                   const double *B,
2093                                                   int ldb,
2094                                                   double *C,
2095                                                   int ldc);
2096
2097 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCgeam(cublasHandle_t handle,
2098                                                   cublasOperation_t transa,
2099                                                   cublasOperation_t transb,
2100                                                   int m,
2101                                                   int n,
2102                                                   const cuComplex *alpha, /* host or device pointer */
2103                                                   const cuComplex *A,
2104                                                   int lda,
2105                                                   const cuComplex *beta, /* host or device pointer */
2106                                                   const cuComplex *B,
2107                                                   int ldb,
2108                                                   cuComplex *C,
2109                                                   int ldc);
2110
2111 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZgeam(cublasHandle_t handle,
2112                                                   cublasOperation_t transa,
2113                                                   cublasOperation_t transb,
2114                                                   int m,
2115                                                   int n,
2116                                                   const cuDoubleComplex *alpha, /* host or device pointer */
2117                                                   const cuDoubleComplex *A,
2118                                                   int lda,
2119                                                   const cuDoubleComplex *beta, /* host or device pointer */
2120                                                   const cuDoubleComplex *B,
2121                                                   int ldb,
2122                                                   cuDoubleComplex *C,
2123                                                   int ldc);
2124
2125 /* Batched LU - GETRF*/
2126 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSgetrfBatched(cublasHandle_t handle,
2127                                                   int n,
2128                                                   float *A[],                      /*Device pointer*/
2129                                                   int lda,
2130                                                   int *P,                          /*Device Pointer*/
2131                                                   int *info,                       /*Device Pointer*/
2132                                                   int batchSize);
2133
2134 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDgetrfBatched(cublasHandle_t handle,
2135                                                   int n,
2136                                                   double *A[],                     /*Device pointer*/
2137                                                   int lda,
2138                                                   int *P,                          /*Device Pointer*/
2139                                                   int *info,                       /*Device Pointer*/
2140                                                   int batchSize);
2141
2142 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCgetrfBatched(cublasHandle_t handle,
2143                                                   int n,
2144                                                   cuComplex *A[],                 /*Device pointer*/
2145                                                   int lda,
2146                                                   int *P,                         /*Device Pointer*/
2147                                                   int *info,                      /*Device Pointer*/
2148                                                   int batchSize);
2149
2150 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZgetrfBatched(cublasHandle_t handle,
2151                                                   int n,
2152                                                   cuDoubleComplex *A[],           /*Device pointer*/
2153                                                   int lda,
2154                                                   int *P,                         /*Device Pointer*/
2155                                                   int *info,                      /*Device Pointer*/
2156                                                   int batchSize);
2157
2158 /* Batched inversion based on LU factorization from getrf */
2159 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSgetriBatched(cublasHandle_t handle,
2160                                                   int n,
2161                                                   const float *A[],               /*Device pointer*/
2162                                                   int lda,
2163                                                   const int *P,                   /*Device pointer*/
2164                                                   float *C[],                     /*Device pointer*/
2165                                                   int ldc,
2166                                                   int *info,
2167                                                   int batchSize);
2168
2169 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDgetriBatched(cublasHandle_t handle,
2170                                                   int n,
2171                                                   const double *A[],              /*Device pointer*/
2172                                                   int lda,
2173                                                   const int *P,                   /*Device pointer*/
2174                                                   double *C[],                    /*Device pointer*/
2175                                                   int ldc,
2176                                                   int *info,
2177                                                   int batchSize);
2178
2179 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCgetriBatched(cublasHandle_t handle,
2180                                                   int n,
2181                                                   const cuComplex *A[],            /*Device pointer*/
2182                                                   int lda,
2183                                                   const int *P,                   /*Device pointer*/
2184                                                   cuComplex *C[],                 /*Device pointer*/
2185                                                   int ldc,
2186                                                   int *info,
2187                                                   int batchSize);
2188
2189 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZgetriBatched(cublasHandle_t handle,
2190                                                   int n,
2191                                                   const cuDoubleComplex *A[],     /*Device pointer*/
2192                                                   int lda,
2193                                                   const int *P,                   /*Device pointer*/
2194                                                   cuDoubleComplex *C[],           /*Device pointer*/
2195                                                   int ldc,
2196                                                   int *info,
2197                                                   int batchSize);
2198
2199
2200
2201 /* TRSM - Batched Triangular Solver */
2202 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasStrsmBatched( cublasHandle_t    handle,
2203                                                           cublasSideMode_t  side,
2204                                                           cublasFillMode_t  uplo,
2205                                                           cublasOperation_t trans,
2206                                                           cublasDiagType_t  diag,
2207                                                           int m,
2208                                                           int n,
2209                                                           const float *alpha,           /*Host or Device Pointer*/
2210                                                           const float *A[],
2211                                                           int lda,
2212                                                           float *B[],
2213                                                           int ldb,
2214                                                           int batchCount);
2215
2216 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDtrsmBatched( cublasHandle_t    handle,
2217                                                           cublasSideMode_t  side,
2218                                                           cublasFillMode_t  uplo,
2219                                                           cublasOperation_t trans,
2220                                                           cublasDiagType_t  diag,
2221                                                           int m,
2222                                                           int n,
2223                                                           const double *alpha,          /*Host or Device Pointer*/
2224                                                           const double *A[],
2225                                                           int lda,
2226                                                           double *B[],
2227                                                           int ldb,
2228                                                           int batchCount);
2229
2230 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCtrsmBatched( cublasHandle_t    handle,
2231                                                           cublasSideMode_t  side,
2232                                                           cublasFillMode_t  uplo,
2233                                                           cublasOperation_t trans,
2234                                                           cublasDiagType_t  diag,
2235                                                           int m,
2236                                                           int n,
2237                                                           const cuComplex *alpha,       /*Host or Device Pointer*/
2238                                                           const cuComplex *A[],
2239                                                           int lda,
2240                                                           cuComplex *B[],
2241                                                           int ldb,
2242                                                           int batchCount);
2243
2244 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZtrsmBatched( cublasHandle_t    handle,
2245                                                           cublasSideMode_t  side,
2246                                                           cublasFillMode_t  uplo,
2247                                                           cublasOperation_t trans,
2248                                                           cublasDiagType_t  diag,
2249                                                           int m,
2250                                                           int n,
2251                                                           const cuDoubleComplex *alpha, /*Host or Device Pointer*/
2252                                                           const cuDoubleComplex *A[],
2253                                                           int lda,
2254                                                           cuDoubleComplex *B[],
2255                                                           int ldb,
2256                                                           int batchCount);
2257
2258 /* Batched - MATINV*/
2259 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSmatinvBatched(cublasHandle_t handle,
2260                                                           int n,
2261                                                           const float *A[],                  /*Device pointer*/
2262                                                           int lda,
2263                                                           float *Ainv[],               /*Device pointer*/
2264                                                           int lda_inv,
2265                                                           int *info,                   /*Device Pointer*/
2266                                                           int batchSize);
2267
2268 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDmatinvBatched(cublasHandle_t handle,
2269                                                           int n,
2270                                                           const double *A[],                 /*Device pointer*/
2271                                                           int lda,
2272                                                           double *Ainv[],              /*Device pointer*/
2273                                                           int lda_inv,
2274                                                           int *info,                   /*Device Pointer*/
2275                                                           int batchSize);
2276
2277 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCmatinvBatched(cublasHandle_t handle,
2278                                                           int n,
2279                                                           const cuComplex *A[],              /*Device pointer*/
2280                                                           int lda,
2281                                                           cuComplex *Ainv[],           /*Device pointer*/
2282                                                           int lda_inv,
2283                                                           int *info,                   /*Device Pointer*/
2284                                                           int batchSize);
2285
2286 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZmatinvBatched(cublasHandle_t handle,
2287                                                           int n,
2288                                                           const cuDoubleComplex *A[],        /*Device pointer*/
2289                                                           int lda,
2290                                                           cuDoubleComplex *Ainv[],     /*Device pointer*/
2291                                                           int lda_inv,
2292                                                           int *info,                   /*Device Pointer*/
2293                                                           int batchSize);
2294
2295 /* Batch QR Factorization */
2296 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSgeqrfBatched( cublasHandle_t handle,
2297                                                            int m,
2298                                                            int n,
2299                                                            float *Aarray[],           /*Device pointer*/
2300                                                            int lda,
2301                                                            float *TauArray[],        /* Device pointer*/
2302                                                            int *info,
2303                                                            int batchSize);
2304
2305 CUBLASAPI cublasStatus_t CUBLASWINAPI  cublasDgeqrfBatched( cublasHandle_t handle,
2306                                                             int m,
2307                                                             int n,
2308                                                             double *Aarray[],           /*Device pointer*/
2309                                                             int lda,
2310                                                             double *TauArray[],        /* Device pointer*/
2311                                                             int *info,
2312                                                             int batchSize);
2313
2314 CUBLASAPI cublasStatus_t CUBLASWINAPI  cublasCgeqrfBatched( cublasHandle_t handle,
2315                                                             int m,
2316                                                             int n,
2317                                                             cuComplex *Aarray[],           /*Device pointer*/
2318                                                             int lda,
2319                                                             cuComplex *TauArray[],        /* Device pointer*/
2320                                                             int *info,
2321                                                             int batchSize);
2322
2323 CUBLASAPI cublasStatus_t CUBLASWINAPI  cublasZgeqrfBatched( cublasHandle_t handle,
2324                                                             int m,
2325                                                             int n,
2326                                                             cuDoubleComplex *Aarray[],           /*Device pointer*/
2327                                                             int lda,
2328                                                             cuDoubleComplex *TauArray[],        /* Device pointer*/
2329                                                             int *info,
2330                                                             int batchSize);
2331 /* Least Square Min only m >= n and Non-transpose supported */
2332 CUBLASAPI cublasStatus_t CUBLASWINAPI  cublasSgelsBatched( cublasHandle_t handle,
2333                                                            cublasOperation_t trans,
2334                                                            int m,
2335                                                            int n,
2336                                                            int nrhs,
2337                                                            float *Aarray[], /*Device pointer*/
2338                                                            int lda,
2339                                                            float *Carray[], /* Device pointer*/
2340                                                            int ldc,
2341                                                            int *info,
2342                                                            int *devInfoArray, /* Device pointer*/
2343                                                            int batchSize );
2344
2345 CUBLASAPI cublasStatus_t CUBLASWINAPI  cublasDgelsBatched( cublasHandle_t handle,
2346                                                            cublasOperation_t trans,
2347                                                            int m,
2348                                                            int n,
2349                                                            int nrhs,
2350                                                            double *Aarray[], /*Device pointer*/
2351                                                            int lda,
2352                                                            double *Carray[], /* Device pointer*/
2353                                                            int ldc,
2354                                                            int *info,
2355                                                            int *devInfoArray, /* Device pointer*/
2356                                                            int batchSize);
2357
2358 CUBLASAPI cublasStatus_t CUBLASWINAPI  cublasCgelsBatched( cublasHandle_t handle,
2359                                                            cublasOperation_t trans,
2360                                                            int m,
2361                                                            int n,
2362                                                            int nrhs,
2363                                                            cuComplex *Aarray[], /*Device pointer*/
2364                                                            int lda,
2365                                                            cuComplex *Carray[], /* Device pointer*/
2366                                                            int ldc,
2367                                                            int *info,
2368                                                            int *devInfoArray,
2369                                                            int batchSize);
2370
2371 CUBLASAPI cublasStatus_t CUBLASWINAPI  cublasZgelsBatched( cublasHandle_t handle,
2372                                                            cublasOperation_t trans,
2373                                                            int m,
2374                                                            int n,
2375                                                            int nrhs,
2376                                                            cuDoubleComplex *Aarray[], /*Device pointer*/
2377                                                            int lda,
2378                                                            cuDoubleComplex *Carray[], /* Device pointer*/
2379                                                            int ldc,
2380                                                            int *info,
2381                                                            int *devInfoArray,
2382                                                            int batchSize);
2383 /* DGMM */
2384 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSdgmm(cublasHandle_t handle,
2385                                                   cublasSideMode_t mode,
2386                                                   int m,
2387                                                   int n,
2388                                                   const float *A,
2389                                                   int lda,
2390                                                   const float *x,
2391                                                   int incx,
2392                                                   float *C,
2393                                                   int ldc);
2394
2395 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDdgmm(cublasHandle_t handle,
2396                                                   cublasSideMode_t mode,
2397                                                   int m,
2398                                                   int n,
2399                                                   const double *A,
2400                                                   int lda,
2401                                                   const double *x,
2402                                                   int incx,
2403                                                   double *C,
2404                                                   int ldc);
2405
2406 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCdgmm(cublasHandle_t handle,
2407                                                   cublasSideMode_t mode,
2408                                                   int m,
2409                                                   int n,
2410                                                   const cuComplex *A,
2411                                                   int lda,
2412                                                   const cuComplex *x,
2413                                                   int incx,
2414                                                   cuComplex *C,
2415                                                   int ldc);
2416
2417 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZdgmm(cublasHandle_t handle,
2418                                                   cublasSideMode_t mode,
2419                                                   int m,
2420                                                   int n,
2421                                                   const cuDoubleComplex *A,
2422                                                   int lda,
2423                                                   const cuDoubleComplex *x,
2424                                                   int incx,
2425                                                   cuDoubleComplex *C,
2426                                                   int ldc);
2427
2428 /* TPTTR : Triangular Pack format to Triangular format */
2429 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasStpttr ( cublasHandle_t handle,
2430                                                      cublasFillMode_t uplo,
2431                                                      int n,
2432                                                      const float *AP,
2433                                                      float *A,
2434                                                      int lda );
2435
2436 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDtpttr ( cublasHandle_t handle,
2437                                                      cublasFillMode_t uplo,
2438                                                      int n,
2439                                                      const double *AP,
2440                                                      double *A,
2441                                                      int lda );
2442
2443 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCtpttr ( cublasHandle_t handle,
2444                                                      cublasFillMode_t uplo,
2445                                                      int n,
2446                                                      const cuComplex *AP,
2447                                                      cuComplex *A,
2448                                                      int lda );
2449
2450 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZtpttr ( cublasHandle_t handle,
2451                                                      cublasFillMode_t uplo,
2452                                                      int n,
2453                                                      const cuDoubleComplex *AP,
2454                                                      cuDoubleComplex *A,
2455                                                      int lda );
2456  /* TRTTP : Triangular format to Triangular Pack format */
2457 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasStrttp ( cublasHandle_t handle,
2458                                                      cublasFillMode_t uplo,
2459                                                      int n,
2460                                                      const float *A,
2461                                                      int lda,
2462                                                      float *AP );
2463
2464 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasDtrttp ( cublasHandle_t handle,
2465                                                      cublasFillMode_t uplo,
2466                                                      int n,
2467                                                      const double *A,
2468                                                      int lda,
2469                                                      double *AP );
2470
2471 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasCtrttp ( cublasHandle_t handle,
2472                                                      cublasFillMode_t uplo,
2473                                                      int n,
2474                                                      const cuComplex *A,
2475                                                      int lda,
2476                                                      cuComplex *AP );
2477
2478 CUBLASAPI cublasStatus_t CUBLASWINAPI cublasZtrttp ( cublasHandle_t handle,
2479                                                      cublasFillMode_t uplo,
2480                                                      int n,
2481                                                      const cuDoubleComplex *A,
2482                                                      int lda,
2483                                                      cuDoubleComplex *AP );
2484
2485 #if defined(__cplusplus)
2486 }
2487 #endif /* __cplusplus */
2488
2489 #endif /* !defined(CUBLAS_API_H_) */