You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
888 lines
40 KiB
C
888 lines
40 KiB
C
1 year ago
|
/*
|
||
|
|
* 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_) */
|