cublas.h

/*
 * Copyright 1993-2019 NVIDIA Corporation. All rights reserved.
 *
 * NOTICE TO LICENSEE:
 *
 * This source code and/or documentation ("Licensed Deliverables") are
 * subject to NVIDIA intellectual property rights under U.S. and
 * international Copyright laws.
 *
 * These Licensed Deliverables contained herein is PROPRIETARY and
 * CONFIDENTIAL to NVIDIA and is being provided under the terms and
 * conditions of a form of NVIDIA software license agreement by and
 * between NVIDIA and Licensee ("License Agreement") or electronically
 * accepted by Licensee.  Notwithstanding any terms or conditions to
 * the contrary in the License Agreement, reproduction or disclosure
 * of the Licensed Deliverables to any third party without the express
 * written consent of NVIDIA is prohibited.
 *
 * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
 * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
 * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  IT IS
 * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
 * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
 * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
 * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
 * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
 * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
 * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
 * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THESE LICENSED DELIVERABLES.
 *
 * U.S. Government End Users.  These Licensed Deliverables are a
 * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
 * 1995), consisting of "commercial computer software" and "commercial
 * computer software documentation" as such terms are used in 48
 * C.F.R. 12.212 (SEPT 1995) and is provided to the U.S. Government
 * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and
 * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
 * U.S. Government End Users acquire the Licensed Deliverables with
 * only those rights set forth herein.
 *
 * Any use of the Licensed Deliverables in individual and commercial
 * software must include, in the user documentation and internal
 * comments to the code, the above Disclaimer and U.S. Government End
 * Users Notice.
 */
 
/*
 * This is the public header file for the CUBLAS library, defining the API
 *
 * CUBLAS is an implementation of BLAS (Basic Linear Algebra Subroutines) 
 * on top of the CUDA runtime. 
 */

#if !defined(CUBLAS_H_)
#define CUBLAS_H_

#include <cuda_runtime.h>

#ifndef CUBLASWINAPI
#ifdef _WIN32
#define CUBLASWINAPI __stdcall
#else
#define CUBLASWINAPI 
#endif
#endif

#undef CUBLASAPI
#ifdef __CUDACC__
#define CUBLASAPI __host__
#else
#define CUBLASAPI
#endif

#include "cublas_api.h"

#if defined(__cplusplus)
extern "C" {
#endif

/* CUBLAS data types */
#define cublasStatus cublasStatus_t

cublasStatus CUBLASWINAPI cublasInit (void);
cublasStatus CUBLASWINAPI cublasShutdown (void);
cublasStatus CUBLASWINAPI cublasGetError (void);

cublasStatus CUBLASWINAPI cublasGetVersion(int *version);
cublasStatus CUBLASWINAPI cublasAlloc (int n, int elemSize, void **devicePtr);

cublasStatus CUBLASWINAPI cublasFree (void *devicePtr);


cublasStatus CUBLASWINAPI cublasSetKernelStream (cudaStream_t stream);



/* ---------------- CUBLAS BLAS1 functions ---------------- */
/* NRM2 */
float CUBLASWINAPI cublasSnrm2 (int n, const float *x, int incx);
double CUBLASWINAPI cublasDnrm2 (int n, const double *x, int incx);
float CUBLASWINAPI cublasScnrm2 (int n, const cuComplex *x, int incx);
double CUBLASWINAPI cublasDznrm2 (int n, const cuDoubleComplex *x, int incx);
/*------------------------------------------------------------------------*/
/* DOT */
float CUBLASWINAPI cublasSdot (int n, const float *x, int incx, const float *y, 
                               int incy);
double CUBLASWINAPI cublasDdot (int n, const double *x, int incx, const double *y, 
                               int incy);
cuComplex CUBLASWINAPI cublasCdotu (int n, const cuComplex *x, int incx, const cuComplex *y, 
                               int incy);
cuComplex CUBLASWINAPI cublasCdotc (int n, const cuComplex *x, int incx, const cuComplex *y, 
                               int incy);
cuDoubleComplex CUBLASWINAPI cublasZdotu (int n, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, 
                               int incy);
cuDoubleComplex CUBLASWINAPI cublasZdotc (int n, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, 
                               int incy);
/*------------------------------------------------------------------------*/
/* SCAL */
void CUBLASWINAPI cublasSscal (int n, float alpha, float *x, int incx);
void CUBLASWINAPI cublasDscal (int n, double alpha, double *x, int incx);
void CUBLASWINAPI cublasCscal (int n, cuComplex alpha, cuComplex *x, int incx);
void CUBLASWINAPI cublasZscal (int n, cuDoubleComplex alpha, cuDoubleComplex *x, int incx);

void CUBLASWINAPI cublasCsscal (int n, float alpha, cuComplex *x, int incx);
void CUBLASWINAPI cublasZdscal (int n, double alpha, cuDoubleComplex *x, int incx);
/*------------------------------------------------------------------------*/
/* AXPY */
void CUBLASWINAPI cublasSaxpy (int n, float alpha, const float *x, int incx, 
                               float *y, int incy);
void CUBLASWINAPI cublasDaxpy (int n, double alpha, const double *x, 
                               int incx, double *y, int incy);
void CUBLASWINAPI cublasCaxpy (int n, cuComplex alpha, const cuComplex *x, 
                               int incx, cuComplex *y, int incy);
void CUBLASWINAPI cublasZaxpy (int n, cuDoubleComplex alpha, const cuDoubleComplex *x, 
                               int incx, cuDoubleComplex *y, int incy);
/*------------------------------------------------------------------------*/
/* COPY */
void CUBLASWINAPI cublasScopy (int n, const float *x, int incx, float *y, 
                               int incy);
void CUBLASWINAPI cublasDcopy (int n, const double *x, int incx, double *y, 
                               int incy);
void CUBLASWINAPI cublasCcopy (int n, const cuComplex *x, int incx, cuComplex *y,
                               int incy);
void CUBLASWINAPI cublasZcopy (int n, const cuDoubleComplex *x, int incx, cuDoubleComplex *y,
                               int incy);
/*------------------------------------------------------------------------*/
/* SWAP */
void CUBLASWINAPI cublasSswap (int n, float *x, int incx, float *y, int incy);
void CUBLASWINAPI cublasDswap (int n, double *x, int incx, double *y, int incy);
void CUBLASWINAPI cublasCswap (int n, cuComplex *x, int incx, cuComplex *y, int incy);
void CUBLASWINAPI cublasZswap (int n, cuDoubleComplex *x, int incx, cuDoubleComplex *y, int incy);           
/*------------------------------------------------------------------------*/
/* AMAX */
int CUBLASWINAPI cublasIsamax (int n, const float *x, int incx);
int CUBLASWINAPI cublasIdamax (int n, const double *x, int incx);
int CUBLASWINAPI cublasIcamax (int n, const cuComplex *x, int incx);
int CUBLASWINAPI cublasIzamax (int n, const cuDoubleComplex *x, int incx);
/*------------------------------------------------------------------------*/
/* AMIN */
int CUBLASWINAPI cublasIsamin (int n, const float *x, int incx);
int CUBLASWINAPI cublasIdamin (int n, const double *x, int incx);

int CUBLASWINAPI cublasIcamin (int n, const cuComplex *x, int incx);
int CUBLASWINAPI cublasIzamin (int n, const cuDoubleComplex *x, int incx);
/*------------------------------------------------------------------------*/
/* ASUM */
float CUBLASWINAPI cublasSasum (int n, const float *x, int incx);
double CUBLASWINAPI cublasDasum (int n, const double *x, int incx);
float CUBLASWINAPI cublasScasum (int n, const cuComplex *x, int incx);
double CUBLASWINAPI cublasDzasum (int n, const cuDoubleComplex *x, int incx);
/*------------------------------------------------------------------------*/
/* ROT */
void CUBLASWINAPI cublasSrot (int n, float *x, int incx, float *y, int incy, 
                              float sc, float ss);
void CUBLASWINAPI cublasDrot (int n, double *x, int incx, double *y, int incy, 
                              double sc, double ss);
void CUBLASWINAPI cublasCrot (int n, cuComplex *x, int incx, cuComplex *y, 
                              int incy, float c, cuComplex s);
void CUBLASWINAPI cublasZrot (int n, cuDoubleComplex *x, int incx, 
                              cuDoubleComplex *y, int incy, double sc, 
                              cuDoubleComplex cs);
void CUBLASWINAPI cublasCsrot (int n, cuComplex *x, int incx, cuComplex *y,
                               int incy, float c, float s);
void CUBLASWINAPI cublasZdrot (int n, cuDoubleComplex *x, int incx, 
                               cuDoubleComplex *y, int incy, double c, double s);
/*------------------------------------------------------------------------*/
/* ROTG */
void CUBLASWINAPI cublasSrotg (float *sa, float *sb, float *sc, float *ss);
void CUBLASWINAPI cublasDrotg (double *sa, double *sb, double *sc, double *ss);
void CUBLASWINAPI cublasCrotg (cuComplex *ca, cuComplex cb, float *sc,
                               cuComplex *cs);                                     
void CUBLASWINAPI cublasZrotg (cuDoubleComplex *ca, cuDoubleComplex cb, double *sc,
                               cuDoubleComplex *cs);                                                               
/*------------------------------------------------------------------------*/
/* ROTM */
void CUBLASWINAPI cublasSrotm(int n, float *x, int incx, float *y, int incy, 
                              const float* sparam);
void CUBLASWINAPI cublasDrotm(int n, double *x, int incx, double *y, int incy, 
                              const double* sparam);
/*------------------------------------------------------------------------*/
/* ROTMG */
void CUBLASWINAPI cublasSrotmg (float *sd1, float *sd2, float *sx1, 
                                const float *sy1, float* sparam);
void CUBLASWINAPI cublasDrotmg (double *sd1, double *sd2, double *sx1, 
                                const double *sy1, double* sparam);
                           
/* --------------- CUBLAS BLAS2 functions  ---------------- */
/* GEMV */
void CUBLASWINAPI cublasSgemv (char trans, int m, int n, float alpha,
                               const float *A, int lda, const float *x, int incx,
                               float beta, float *y, int incy);
void CUBLASWINAPI cublasDgemv (char trans, int m, int n, double alpha,
                               const double *A, int lda, const double *x, int incx,
                               double beta, double *y, int incy);
void CUBLASWINAPI cublasCgemv (char trans, int m, int n, cuComplex alpha,
                               const cuComplex *A, int lda, const cuComplex *x, int incx,
                               cuComplex beta, cuComplex *y, int incy);
void CUBLASWINAPI cublasZgemv (char trans, int m, int n, cuDoubleComplex alpha,
                               const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx,
                               cuDoubleComplex beta, cuDoubleComplex *y, int incy);
/*------------------------------------------------------------------------*/
/* GBMV */
void CUBLASWINAPI cublasSgbmv (char trans, int m, int n, int kl, int ku, 
                               float alpha, const float *A, int lda, 
                               const float *x, int incx, float beta, float *y, 
                               int incy);
void CUBLASWINAPI cublasDgbmv (char trans, int m, int n, int kl, int ku, 
                               double alpha, const double *A, int lda, 
                               const double *x, int incx, double beta, double *y, 
                               int incy);
void CUBLASWINAPI cublasCgbmv (char trans, int m, int n, int kl, int ku, 
                               cuComplex alpha, const cuComplex *A, int lda, 
                               const cuComplex *x, int incx, cuComplex beta, cuComplex *y, 
                               int incy);
void CUBLASWINAPI cublasZgbmv (char trans, int m, int n, int kl, int ku, 
                               cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, 
                               const cuDoubleComplex *x, int incx, cuDoubleComplex beta, cuDoubleComplex *y, 
                               int incy);                  
/*------------------------------------------------------------------------*/
/* TRMV */
void CUBLASWINAPI cublasStrmv (char uplo, char trans, char diag, int n, 
                               const float *A, int lda, float *x, int incx);
void CUBLASWINAPI cublasDtrmv (char uplo, char trans, char diag, int n, 
                               const double *A, int lda, double *x, int incx);
void CUBLASWINAPI cublasCtrmv (char uplo, char trans, char diag, int n, 
                               const cuComplex *A, int lda, cuComplex *x, int incx);
void CUBLASWINAPI cublasZtrmv (char uplo, char trans, char diag, int n, 
                               const cuDoubleComplex *A, int lda, cuDoubleComplex *x, int incx);
/*------------------------------------------------------------------------*/
/* TBMV */
void CUBLASWINAPI cublasStbmv (char uplo, char trans, char diag, int n, int k, 
                               const float *A, int lda, float *x, int incx);
void CUBLASWINAPI cublasDtbmv (char uplo, char trans, char diag, int n, int k, 
                               const double *A, int lda, double *x, int incx);
void CUBLASWINAPI cublasCtbmv (char uplo, char trans, char diag, int n, int k, 
                               const cuComplex *A, int lda, cuComplex *x, int incx);
void CUBLASWINAPI cublasZtbmv (char uplo, char trans, char diag, int n, int k, 
                               const cuDoubleComplex *A, int lda, cuDoubleComplex *x, int incx);
/*------------------------------------------------------------------------*/
/* TPMV */                                                    
void CUBLASWINAPI cublasStpmv(char uplo, char trans, char diag, int n, const float *AP, float *x, int incx);

void CUBLASWINAPI cublasDtpmv(char uplo, char trans, char diag, int n, const double *AP, double *x, int incx);

void CUBLASWINAPI cublasCtpmv(char uplo, char trans, char diag, int n, const cuComplex *AP, cuComplex *x, int incx);
                                         
void CUBLASWINAPI cublasZtpmv(char uplo, char trans, char diag, int n, const cuDoubleComplex *AP, cuDoubleComplex *x, int incx);
/*------------------------------------------------------------------------*/
/* TRSV */
void CUBLASWINAPI cublasStrsv(char uplo, char trans, char diag, int n, const float *A, int lda, float *x, int incx);

void CUBLASWINAPI cublasDtrsv(char uplo, char trans, char diag, int n, const double *A, int lda, double *x, int incx);

void CUBLASWINAPI cublasCtrsv(char uplo, char trans, char diag, int n, const cuComplex *A, int lda, cuComplex *x, int incx);

void CUBLASWINAPI cublasZtrsv(char uplo, char trans, char diag, int n, const cuDoubleComplex *A, int lda, 
                              cuDoubleComplex *x, int incx);       
/*------------------------------------------------------------------------*/
/* TPSV */
void CUBLASWINAPI cublasStpsv(char uplo, char trans, char diag, int n, const float *AP, 
                              float *x, int incx);
                                                                                                            
void CUBLASWINAPI cublasDtpsv(char uplo, char trans, char diag, int n, const double *AP, double *x, int incx);

void CUBLASWINAPI cublasCtpsv(char uplo, char trans, char diag, int n, const cuComplex *AP, cuComplex *x, int incx);

void CUBLASWINAPI cublasZtpsv(char uplo, char trans, char diag, int n, const cuDoubleComplex *AP, 
                              cuDoubleComplex *x, int incx);
/*------------------------------------------------------------------------*/                                         
/* TBSV */                                         
void CUBLASWINAPI cublasStbsv(char uplo, char trans, 
                              char diag, int n, int k, const float *A, 
                              int lda, float *x, int incx);
    
void CUBLASWINAPI cublasDtbsv(char uplo, char trans, 
                              char diag, int n, int k, const double *A, 
                              int lda, double *x, int incx);
void CUBLASWINAPI cublasCtbsv(char uplo, char trans, 
                              char diag, int n, int k, const cuComplex *A, 
                              int lda, cuComplex *x, int incx);      
                                         
void CUBLASWINAPI cublasZtbsv(char uplo, char trans, 
                              char diag, int n, int k, const cuDoubleComplex *A, 
                              int lda, cuDoubleComplex *x, int incx);  
/*------------------------------------------------------------------------*/                                         
/* SYMV/HEMV */
void CUBLASWINAPI cublasSsymv (char uplo, int n, float alpha, const float *A,
                               int lda, const float *x, int incx, float beta, 
                               float *y, int incy);
void CUBLASWINAPI cublasDsymv (char uplo, int n, double alpha, const double *A,
                               int lda, const double *x, int incx, double beta, 
                               double *y, int incy);
void CUBLASWINAPI cublasChemv (char uplo, int n, cuComplex alpha, const cuComplex *A,
                               int lda, const cuComplex *x, int incx, cuComplex beta, 
                               cuComplex *y, int incy);
void CUBLASWINAPI cublasZhemv (char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex *A,
                               int lda, const cuDoubleComplex *x, int incx, cuDoubleComplex beta, 
                               cuDoubleComplex *y, int incy);
/*------------------------------------------------------------------------*/       
/* SBMV/HBMV */
void CUBLASWINAPI cublasSsbmv (char uplo, int n, int k, float alpha, 
                               const float *A, int lda, const float *x, int incx, 
                               float beta, float *y, int incy);
void CUBLASWINAPI cublasDsbmv (char uplo, int n, int k, double alpha, 
                               const double *A, int lda, const double *x, int incx, 
                               double beta, double *y, int incy);
void CUBLASWINAPI cublasChbmv (char uplo, int n, int k, cuComplex alpha, 
                               const cuComplex *A, int lda, const cuComplex *x, int incx, 
                               cuComplex beta, cuComplex *y, int incy);
void CUBLASWINAPI cublasZhbmv (char uplo, int n, int k, cuDoubleComplex alpha, 
                               const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, 
                               cuDoubleComplex beta, cuDoubleComplex *y, int incy);
/*------------------------------------------------------------------------*/       
/* SPMV/HPMV */
void CUBLASWINAPI cublasSspmv(char uplo, int n, float alpha,
                              const float *AP, const float *x,
                              int incx, float beta, float *y, int incy);
void CUBLASWINAPI cublasDspmv(char uplo, int n, double alpha,
                              const double *AP, const double *x,
                              int incx, double beta, double *y, int incy);
void CUBLASWINAPI cublasChpmv(char uplo, int n, cuComplex alpha,
                              const cuComplex *AP, const cuComplex *x,
                              int incx, cuComplex beta, cuComplex *y, int incy);
void CUBLASWINAPI cublasZhpmv(char uplo, int n, cuDoubleComplex alpha,
                              const cuDoubleComplex *AP, const cuDoubleComplex *x,
                              int incx, cuDoubleComplex beta, cuDoubleComplex *y, int incy);

/*------------------------------------------------------------------------*/       
/* GER */
void CUBLASWINAPI cublasSger (int m, int n, float alpha, const float *x, int incx,
                              const float *y, int incy, float *A, int lda);
void CUBLASWINAPI cublasDger (int m, int n, double alpha, const double *x, int incx,
                              const double *y, int incy, double *A, int lda);

void CUBLASWINAPI cublasCgeru (int m, int n, cuComplex alpha, const cuComplex *x,
                               int incx, const cuComplex *y, int incy,
                               cuComplex *A, int lda);
void CUBLASWINAPI cublasCgerc (int m, int n, cuComplex alpha, const cuComplex *x,
                               int incx, const cuComplex *y, int incy,
                               cuComplex *A, int lda);
void CUBLASWINAPI cublasZgeru (int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *x,
                               int incx, const cuDoubleComplex *y, int incy,
                               cuDoubleComplex *A, int lda);
void CUBLASWINAPI cublasZgerc (int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *x,
                               int incx, const cuDoubleComplex *y, int incy,
                               cuDoubleComplex *A, int lda);
/*------------------------------------------------------------------------*/       
/* SYR/HER */
void CUBLASWINAPI cublasSsyr (char uplo, int n, float alpha, const float *x,
                              int incx, float *A, int lda);
void CUBLASWINAPI cublasDsyr (char uplo, int n, double alpha, const double *x,
                              int incx, double *A, int lda);

void CUBLASWINAPI cublasCher (char uplo, int n, float alpha, 
                              const cuComplex *x, int incx, cuComplex *A, int lda);
void CUBLASWINAPI cublasZher (char uplo, int n, double alpha, 
                              const cuDoubleComplex *x, int incx, cuDoubleComplex *A, int lda);

/*------------------------------------------------------------------------*/       
/* SPR/HPR */
void CUBLASWINAPI cublasSspr (char uplo, int n, float alpha, const float *x,
                              int incx, float *AP);
void CUBLASWINAPI cublasDspr (char uplo, int n, double alpha, const double *x,
                              int incx, double *AP);
void CUBLASWINAPI cublasChpr (char uplo, int n, float alpha, const cuComplex *x,
                              int incx, cuComplex *AP);
void CUBLASWINAPI cublasZhpr (char uplo, int n, double alpha, const cuDoubleComplex *x,
                              int incx, cuDoubleComplex *AP);
/*------------------------------------------------------------------------*/       
/* SYR2/HER2 */
void CUBLASWINAPI cublasSsyr2 (char uplo, int n, float alpha, const float *x, 
                               int incx, const float *y, int incy, float *A, 
                               int lda);
void CUBLASWINAPI cublasDsyr2 (char uplo, int n, double alpha, const double *x, 
                               int incx, const double *y, int incy, double *A, 
                               int lda);
void CUBLASWINAPI cublasCher2 (char uplo, int n, cuComplex alpha, const cuComplex *x, 
                               int incx, const cuComplex *y, int incy, cuComplex *A, 
                               int lda);
void CUBLASWINAPI cublasZher2 (char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex *x, 
                               int incx, const cuDoubleComplex *y, int incy, cuDoubleComplex *A, 
                               int lda);

/*------------------------------------------------------------------------*/       
/* SPR2/HPR2 */
void CUBLASWINAPI cublasSspr2 (char uplo, int n, float alpha, const float *x, 
                               int incx, const float *y, int incy, float *AP);
void CUBLASWINAPI cublasDspr2 (char uplo, int n, double alpha,
                               const double *x, int incx, const double *y,
                               int incy, double *AP);
void CUBLASWINAPI cublasChpr2 (char uplo, int n, cuComplex alpha,
                               const cuComplex *x, int incx, const cuComplex *y,
                               int incy, cuComplex *AP);
void CUBLASWINAPI cublasZhpr2 (char uplo, int n, cuDoubleComplex alpha,
                               const cuDoubleComplex *x, int incx, const cuDoubleComplex *y,
                               int incy, cuDoubleComplex *AP);
/* ------------------------BLAS3 Functions ------------------------------- */
/* GEMM */
void CUBLASWINAPI cublasSgemm (char transa, char transb, int m, int n, int k, 
                               float alpha, const float *A, int lda, 
                               const float *B, int ldb, float beta, float *C, 
                               int ldc);
void CUBLASWINAPI cublasDgemm (char transa, char transb, int m, int n, int k,
                               double alpha, const double *A, int lda, 
                               const double *B, int ldb, double beta, double *C, 
                               int ldc);              
void CUBLASWINAPI cublasCgemm (char transa, char transb, int m, int n, int k, 
                               cuComplex alpha, const cuComplex *A, int lda,
                               const cuComplex *B, int ldb, cuComplex beta,
                               cuComplex *C, int ldc);
void CUBLASWINAPI cublasZgemm (char transa, char transb, int m, int n,
                               int k, cuDoubleComplex alpha,
                               const cuDoubleComplex *A, int lda,
                               const cuDoubleComplex *B, int ldb,
                               cuDoubleComplex beta, cuDoubleComplex *C,
                               int ldc);                   
/* -------------------------------------------------------*/
/* SYRK */
void CUBLASWINAPI cublasSsyrk (char uplo, char trans, int n, int k, float alpha, 
                               const float *A, int lda, float beta, float *C, 
                               int ldc);
void CUBLASWINAPI cublasDsyrk (char uplo, char trans, int n, int k,
                               double alpha, const double *A, int lda,
                               double beta, double *C, int ldc);

void CUBLASWINAPI cublasCsyrk (char uplo, char trans, int n, int k,
                               cuComplex alpha, const cuComplex *A, int lda,
                               cuComplex beta, cuComplex *C, int ldc);
void CUBLASWINAPI cublasZsyrk (char uplo, char trans, int n, int k,
                               cuDoubleComplex alpha,
                               const cuDoubleComplex *A, int lda,
                               cuDoubleComplex beta,
                               cuDoubleComplex *C, int ldc);
/* ------------------------------------------------------- */
/* HERK */
void CUBLASWINAPI cublasCherk (char uplo, char trans, int n, int k,
                               float alpha, const cuComplex *A, int lda,
                               float beta, cuComplex *C, int ldc);
void CUBLASWINAPI cublasZherk (char uplo, char trans, int n, int k,
                               double alpha,
                               const cuDoubleComplex *A, int lda,
                               double beta,
                               cuDoubleComplex *C, int ldc);
/* ------------------------------------------------------- */
/* SYR2K */
void CUBLASWINAPI cublasSsyr2k (char uplo, char trans, int n, int k, float alpha, 
                                const float *A, int lda, const float *B, int ldb, 
                                float beta, float *C, int ldc);

void CUBLASWINAPI cublasDsyr2k (char uplo, char trans, int n, int k,
                                double alpha, const double *A, int lda,
                                const double *B, int ldb, double beta,
                                double *C, int ldc);
void CUBLASWINAPI cublasCsyr2k (char uplo, char trans, int n, int k,
                                cuComplex alpha, const cuComplex *A, int lda,
                                const cuComplex *B, int ldb, cuComplex beta,
                                cuComplex *C, int ldc);

void CUBLASWINAPI cublasZsyr2k (char uplo, char trans, int n, int k,
                                cuDoubleComplex alpha, const cuDoubleComplex *A, int lda,
                                const cuDoubleComplex *B, int ldb, cuDoubleComplex beta,
                                cuDoubleComplex *C, int ldc);                             
/* ------------------------------------------------------- */
/* HER2K */
void CUBLASWINAPI cublasCher2k (char uplo, char trans, int n, int k,
                                cuComplex alpha, const cuComplex *A, int lda,
                                const cuComplex *B, int ldb, float beta,
                                cuComplex *C, int ldc);

void CUBLASWINAPI cublasZher2k (char uplo, char trans, int n, int k,
                                cuDoubleComplex alpha, const cuDoubleComplex *A, int lda,
                                const cuDoubleComplex *B, int ldb, double beta,
                                cuDoubleComplex *C, int ldc); 

/*------------------------------------------------------------------------*/       
/* SYMM*/
void CUBLASWINAPI cublasSsymm (char side, char uplo, int m, int n, float alpha, 
                               const float *A, int lda, const float *B, int ldb,
                               float beta, float *C, int ldc);
void CUBLASWINAPI cublasDsymm (char side, char uplo, int m, int n, double alpha, 
                               const double *A, int lda, const double *B, int ldb,
                               double beta, double *C, int ldc);
          
void CUBLASWINAPI cublasCsymm (char side, char uplo, int m, int n, cuComplex alpha, 
                               const cuComplex *A, int lda, const cuComplex *B, int ldb,
                               cuComplex beta, cuComplex *C, int ldc);
          
void CUBLASWINAPI cublasZsymm (char side, char uplo, int m, int n, cuDoubleComplex alpha, 
                               const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb,
                               cuDoubleComplex beta, cuDoubleComplex *C, int ldc);
/*------------------------------------------------------------------------*/       
/* HEMM*/
void CUBLASWINAPI cublasChemm (char side, char uplo, int m, int n,
                               cuComplex alpha, const cuComplex *A, int lda,
                               const cuComplex *B, int ldb, cuComplex beta,
                               cuComplex *C, int ldc);
void CUBLASWINAPI cublasZhemm (char side, char uplo, int m, int n,
                               cuDoubleComplex alpha, const cuDoubleComplex *A, int lda,
                               const cuDoubleComplex *B, int ldb, cuDoubleComplex beta,
                               cuDoubleComplex *C, int ldc);  

/*------------------------------------------------------------------------*/       
/* TRSM*/
void CUBLASWINAPI cublasStrsm (char side, char uplo, char transa, char diag,
                               int m, int n, float alpha, const float *A, int lda,
                               float *B, int ldb);

void CUBLASWINAPI cublasDtrsm (char side, char uplo, char transa,
                               char diag, int m, int n, double alpha,
                               const double *A, int lda, double *B,
                               int ldb);

void CUBLASWINAPI cublasCtrsm (char side, char uplo, char transa, char diag,
                               int m, int n, cuComplex alpha, const cuComplex *A,
                               int lda, cuComplex *B, int ldb);

void CUBLASWINAPI cublasZtrsm (char side, char uplo, char transa,
                               char diag, int m, int n, cuDoubleComplex alpha,
                               const cuDoubleComplex *A, int lda,
                               cuDoubleComplex *B, int ldb);                                                        
/*------------------------------------------------------------------------*/       
/* TRMM*/
void CUBLASWINAPI cublasStrmm (char side, char uplo, char transa, char diag,
                               int m, int n, float alpha, const float *A, int lda,
                               float *B, int ldb);
void CUBLASWINAPI cublasDtrmm (char side, char uplo, char transa,
                               char diag, int m, int n, double alpha,
                               const double *A, int lda, double *B,
                               int ldb);
void CUBLASWINAPI cublasCtrmm (char side, char uplo, char transa, char diag,
                               int m, int n, cuComplex alpha, const cuComplex *A,
                               int lda, cuComplex *B, int ldb);
void CUBLASWINAPI cublasZtrmm (char side, char uplo, char transa,
                               char diag, int m, int n, cuDoubleComplex alpha,
                               const cuDoubleComplex *A, int lda, cuDoubleComplex *B,
                               int ldb);

#if defined(__cplusplus)
}
#endif /* __cplusplus */

#endif /* !defined(CUBLAS_H_) */