Add files using upload-large-folder tool

8762e9b verified about 1 year ago

41.2 kB

	/*
	* 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_

	#if defined(CUBLAS_V2_H_)
	#error "It is an error to include both cublas.h and cublas_v2.h"
	#endif

	#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_) */