jcuda.jcublas
Class JCublas2

java.lang.Object
  extended by jcuda.jcublas.JCublas2

public class JCublas2
extends java.lang.Object

Java bindings for CUBLAS, the NVIDIA CUDA BLAS library.
This class contains the new CUBLAS API that was introduced with CUDA 4.0

Most comments are taken from the CUBLAS header file.


Method Summary
static int cublasCaxpy(cublasHandle handle, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasCcopy(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasCdgmm(cublasHandle handle, int mode, int m, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer C, int ldc)
           
static int cublasCdotc(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer result)
          host or device pointer
static int cublasCdotu(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer result)
          host or device pointer
static int cublasCgbmv(cublasHandle handle, int trans, int m, int n, int kl, int ku, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasCgeam(cublasHandle handle, int transa, int transb, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer beta, jcuda.Pointer B, int ldb, jcuda.Pointer C, int ldc)
           
static int cublasCgemm(cublasHandle handle, int transa, int transb, int m, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasCgemmBatched(cublasHandle handle, int transa, int transb, int m, int n, int k, jcuda.Pointer alpha, jcuda.Pointer Aarray, int lda, jcuda.Pointer Barray, int ldb, jcuda.Pointer beta, jcuda.Pointer Carray, int ldc, int batchCount)
           
static int cublasCgemv(cublasHandle handle, int trans, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasCgerc(cublasHandle handle, int m, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasCgeru(cublasHandle handle, int m, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasCgetrfBatched(cublasHandle handle, int n, jcuda.Pointer A, int lda, jcuda.Pointer P, jcuda.Pointer INFO, int batchSize)
           
static int cublasChbmv(cublasHandle handle, int uplo, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasChemm(cublasHandle handle, int side, int uplo, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasChemv(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasCher(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer A, int lda)
           
static int cublasCher2(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasCher2k(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasCherk(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasChpmv(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer AP, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasChpr(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer AP)
           
static int cublasChpr2(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer AP)
           
static int cublasCreate(cublasHandle handle)
           
static int cublasCrot(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer c, jcuda.Pointer s)
          host or device pointer
static int cublasCrotg(cublasHandle handle, jcuda.Pointer a, jcuda.Pointer b, jcuda.Pointer c, jcuda.Pointer s)
          host or device pointer
static int cublasCscal(cublasHandle handle, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx)
           
static int cublasCsrot(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer c, jcuda.Pointer s)
          host or device pointer
static int cublasCsscal(cublasHandle handle, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx)
           
static int cublasCswap(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasCsymm(cublasHandle handle, int side, int uplo, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasCsymv(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasCsyr(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer A, int lda)
           
static int cublasCsyr2(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasCsyr2k(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasCsyrk(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasCtbmv(cublasHandle handle, int uplo, int trans, int diag, int n, int k, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasCtbsv(cublasHandle handle, int uplo, int trans, int diag, int n, int k, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasCtpmv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer AP, jcuda.Pointer x, int incx)
           
static int cublasCtpsv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer AP, jcuda.Pointer x, int incx)
           
static int cublasCtrmm(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer C, int ldc)
           
static int cublasCtrmv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasCtrsm(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb)
           
static int cublasCtrsmBatched(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, int batchCount)
           
static int cublasCtrsv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasDasum(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasDaxpy(cublasHandle handle, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasDcopy(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasDdgmm(cublasHandle handle, int mode, int m, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer C, int ldc)
           
static int cublasDdot(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer result)
          host or device pointer
static int cublasDestroy(cublasHandle handle)
           
static int cublasDgbmv(cublasHandle handle, int trans, int m, int n, int kl, int ku, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasDgeam(cublasHandle handle, int transa, int transb, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer beta, jcuda.Pointer B, int ldb, jcuda.Pointer C, int ldc)
           
static int cublasDgemm(cublasHandle handle, int transa, int transb, int m, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasDgemmBatched(cublasHandle handle, int transa, int transb, int m, int n, int k, jcuda.Pointer alpha, jcuda.Pointer Aarray, int lda, jcuda.Pointer Barray, int ldb, jcuda.Pointer beta, jcuda.Pointer Carray, int ldc, int batchCount)
           
static int cublasDgemv(cublasHandle handle, int trans, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasDger(cublasHandle handle, int m, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasDgetrfBatched(cublasHandle handle, int n, jcuda.Pointer A, int lda, jcuda.Pointer P, jcuda.Pointer INFO, int batchSize)
           
static int cublasDnrm2(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasDrot(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer c, jcuda.Pointer s)
          host or device pointer
static int cublasDrotg(cublasHandle handle, jcuda.Pointer a, jcuda.Pointer b, jcuda.Pointer c, jcuda.Pointer s)
          host or device pointer
static int cublasDrotm(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer param)
          host or device pointer
static int cublasDrotmg(cublasHandle handle, jcuda.Pointer d1, jcuda.Pointer d2, jcuda.Pointer x1, jcuda.Pointer y1, jcuda.Pointer param)
          host or device pointer
static int cublasDsbmv(cublasHandle handle, int uplo, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasDscal(cublasHandle handle, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx)
           
static int cublasDspmv(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer AP, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasDspr(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer AP)
           
static int cublasDspr2(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer AP)
           
static int cublasDswap(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasDsymm(cublasHandle handle, int side, int uplo, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasDsymv(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasDsyr(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer A, int lda)
           
static int cublasDsyr2(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasDsyr2k(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasDsyrk(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasDtbmv(cublasHandle handle, int uplo, int trans, int diag, int n, int k, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasDtbsv(cublasHandle handle, int uplo, int trans, int diag, int n, int k, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasDtpmv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer AP, jcuda.Pointer x, int incx)
           
static int cublasDtpsv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer AP, jcuda.Pointer x, int incx)
           
static int cublasDtrmm(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer C, int ldc)
           
static int cublasDtrmv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasDtrsm(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb)
           
static int cublasDtrsmBatched(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, int batchCount)
           
static int cublasDtrsv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasDzasum(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasDznrm2(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasGetAtomicsMode(cublasHandle handle, int[] mode)
           
static int cublasGetMatrix(int rows, int cols, int elemSize, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb)
           cublasStatus_t cublasGetMatrix (int rows, int cols, int elemSize, const void *A, int lda, void *B, int ldb) copies a tile of rows x cols elements from a matrix A in GPU memory space to a matrix B in CPU memory space.
static int cublasGetMatrixAsync(int rows, int cols, int elemSize, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.runtime.cudaStream_t stream)
           cublasStatus_t cublasGetMatrixAsync (int rows, int cols, int elemSize, const void *A, int lda, void *B, int ldb, cudaStream_t stream) cublasGetMatrixAsync has the same functionnality as cublasGetMatrix but the transfer is done asynchronously within the CUDA stream passed in parameter.
static int cublasGetPointerMode(cublasHandle handle, int[] mode)
           
static int cublasGetStream(cublasHandle handle, jcuda.runtime.cudaStream_t streamId)
           
static int cublasGetVector(int n, int elemSize, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           cublasStatus_t cublasGetVector (int n, int elemSize, const void *x, int incx, void *y, int incy) copies n elements from a vector x in GPU memory space to a vector y in CPU memory space.
static int cublasGetVectorAsync(int n, int elemSize, jcuda.Pointer devicePtr, int incx, jcuda.Pointer hostPtr, int incy, jcuda.runtime.cudaStream_t stream)
           cublasStatus cublasGetVectorAsync( int n, int elemSize, const void *x, int incx, void *y, int incy, cudaStream_t stream) cublasGetVectorAsync has the same functionnality as cublasGetVector but the transfer is done asynchronously within the CUDA stream passed in parameter.
static int cublasGetVersion(cublasHandle handle, int[] version)
           
static int cublasIcamax(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasIcamin(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasIdamax(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasIdamin(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasIsamax(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
           
static int cublasIsamin(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasIzamax(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasIzamin(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasSasum(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasSaxpy(cublasHandle handle, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasScasum(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasScnrm2(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
          host or device pointer
static int cublasScopy(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasSdgmm(cublasHandle handle, int mode, int m, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer C, int ldc)
           
static int cublasSdot(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer result)
          host or device pointer
static int cublasSetAtomicsMode(cublasHandle handle, int mode)
           
static int cublasSetMatrix(int rows, int cols, int elemSize, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb)
           cublasStatus_t cublasSetMatrix (int rows, int cols, int elemSize, const void *A, int lda, void *B, int ldb) copies a tile of rows x cols elements from a matrix A in CPU memory space to a matrix B in GPU memory space.
static int cublasSetMatrixAsync(int rows, int cols, int elemSize, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.runtime.cudaStream_t stream)
           cublasStatus_t cublasSetMatrixAsync (int rows, int cols, int elemSize, const void *A, int lda, void *B, int ldb, cudaStream_t stream) cublasSetMatrixAsync has the same functionnality as cublasSetMatrix but the transfer is done asynchronously within the CUDA stream passed in parameter.
static int cublasSetPointerMode(cublasHandle handle, int mode)
           
static int cublasSetStream(cublasHandle handle, jcuda.runtime.cudaStream_t streamId)
           
static int cublasSetVector(int n, int elemSize, jcuda.Pointer x, int incx, jcuda.Pointer devicePtr, int incy)
           cublasStatus_t cublasSetVector (int n, int elemSize, const void *x, int incx, void *y, int incy) copies n elements from a vector x in CPU memory space to a vector y in GPU memory space.
static int cublasSetVectorAsync(int n, int elemSize, jcuda.Pointer hostPtr, int incx, jcuda.Pointer devicePtr, int incy, jcuda.runtime.cudaStream_t stream)
           cublasStatus cublasSetVectorAsync ( int n, int elemSize, const void *x, int incx, void *y, int incy, cudaStream_t stream ); cublasSetVectorAsync has the same functionnality as cublasSetVector but the transfer is done asynchronously within the CUDA stream passed in parameter.
static int cublasSgbmv(cublasHandle handle, int trans, int m, int n, int kl, int ku, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasSgeam(cublasHandle handle, int transa, int transb, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer beta, jcuda.Pointer B, int ldb, jcuda.Pointer C, int ldc)
           
static int cublasSgemm(cublasHandle handle, int transa, int transb, int m, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasSgemmBatched(cublasHandle handle, int transa, int transb, int m, int n, int k, jcuda.Pointer alpha, jcuda.Pointer Aarray, int lda, jcuda.Pointer Barray, int ldb, jcuda.Pointer beta, jcuda.Pointer Carray, int ldc, int batchCount)
           
static int cublasSgemv(cublasHandle handle, int trans, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
          host or device pointer
static int cublasSger(cublasHandle handle, int m, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasSgetrfBatched(cublasHandle handle, int n, jcuda.Pointer A, int lda, jcuda.Pointer P, jcuda.Pointer INFO, int batchSize)
           
static int cublasSnrm2(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer result)
           
static int cublasSrot(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer c, jcuda.Pointer s)
          host or device pointer
static int cublasSrotg(cublasHandle handle, jcuda.Pointer a, jcuda.Pointer b, jcuda.Pointer c, jcuda.Pointer s)
          host or device pointer
static int cublasSrotm(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer param)
          host or device pointer
static int cublasSrotmg(cublasHandle handle, jcuda.Pointer d1, jcuda.Pointer d2, jcuda.Pointer x1, jcuda.Pointer y1, jcuda.Pointer param)
          host or device pointer
static int cublasSsbmv(cublasHandle handle, int uplo, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasSscal(cublasHandle handle, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx)
          host or device pointer
static int cublasSspmv(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer AP, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasSspr(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer AP)
           
static int cublasSspr2(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer AP)
           
static int cublasSswap(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasSsymm(cublasHandle handle, int side, int uplo, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasSsymv(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasSsyr(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer A, int lda)
           
static int cublasSsyr2(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasSsyr2k(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasSsyrk(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasStbmv(cublasHandle handle, int uplo, int trans, int diag, int n, int k, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasStbsv(cublasHandle handle, int uplo, int trans, int diag, int n, int k, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasStpmv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer AP, jcuda.Pointer x, int incx)
           
static int cublasStpsv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer AP, jcuda.Pointer x, int incx)
           
static int cublasStrmm(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer C, int ldc)
           
static int cublasStrmv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasStrsm(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb)
           
static int cublasStrsmBatched(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, int batchCount)
           
static int cublasStrsv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static void cublasXerbla(byte[] srName, int info)
           
static int cublasZaxpy(cublasHandle handle, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasZcopy(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasZdgmm(cublasHandle handle, int mode, int m, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer C, int ldc)
           
static int cublasZdotc(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer result)
          host or device pointer
static int cublasZdotu(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer result)
          host or device pointer
static int cublasZdrot(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer c, jcuda.Pointer s)
          host or device pointer
static int cublasZdscal(cublasHandle handle, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx)
           
static int cublasZgbmv(cublasHandle handle, int trans, int m, int n, int kl, int ku, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasZgeam(cublasHandle handle, int transa, int transb, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer beta, jcuda.Pointer B, int ldb, jcuda.Pointer C, int ldc)
           
static int cublasZgemm(cublasHandle handle, int transa, int transb, int m, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasZgemmBatched(cublasHandle handle, int transa, int transb, int m, int n, int k, jcuda.Pointer alpha, jcuda.Pointer Aarray, int lda, jcuda.Pointer Barray, int ldb, jcuda.Pointer beta, jcuda.Pointer Carray, int ldc, int batchCount)
           
static int cublasZgemv(cublasHandle handle, int trans, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasZgerc(cublasHandle handle, int m, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasZgeru(cublasHandle handle, int m, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasZgetrfBatched(cublasHandle handle, int n, jcuda.Pointer A, int lda, jcuda.Pointer P, jcuda.Pointer INFO, int batchSize)
           
static int cublasZhbmv(cublasHandle handle, int uplo, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasZhemm(cublasHandle handle, int side, int uplo, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasZhemv(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasZher(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer A, int lda)
           
static int cublasZher2(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasZher2k(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasZherk(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasZhpmv(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer AP, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasZhpr(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer AP)
           
static int cublasZhpr2(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer AP)
           
static int cublasZrot(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer c, jcuda.Pointer s)
          host or device pointer
static int cublasZrotg(cublasHandle handle, jcuda.Pointer a, jcuda.Pointer b, jcuda.Pointer c, jcuda.Pointer s)
          host or device pointer
static int cublasZscal(cublasHandle handle, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx)
           
static int cublasZswap(cublasHandle handle, int n, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy)
           
static int cublasZsymm(cublasHandle handle, int side, int uplo, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasZsymv(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx, jcuda.Pointer beta, jcuda.Pointer y, int incy)
           
static int cublasZsyr(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer A, int lda)
           
static int cublasZsyr2(cublasHandle handle, int uplo, int n, jcuda.Pointer alpha, jcuda.Pointer x, int incx, jcuda.Pointer y, int incy, jcuda.Pointer A, int lda)
           
static int cublasZsyr2k(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasZsyrk(cublasHandle handle, int uplo, int trans, int n, int k, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cublasZtbmv(cublasHandle handle, int uplo, int trans, int diag, int n, int k, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasZtbsv(cublasHandle handle, int uplo, int trans, int diag, int n, int k, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasZtpmv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer AP, jcuda.Pointer x, int incx)
           
static int cublasZtpsv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer AP, jcuda.Pointer x, int incx)
           
static int cublasZtrmm(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, jcuda.Pointer C, int ldc)
           
static int cublasZtrmv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static int cublasZtrsm(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb)
           
static int cublasZtrsmBatched(cublasHandle handle, int side, int uplo, int trans, int diag, int m, int n, jcuda.Pointer alpha, jcuda.Pointer A, int lda, jcuda.Pointer B, int ldb, int batchCount)
           
static int cublasZtrsv(cublasHandle handle, int uplo, int trans, int diag, int n, jcuda.Pointer A, int lda, jcuda.Pointer x, int incx)
           
static void initialize()
          Initializes the native library.
static void setExceptionsEnabled(boolean enabled)
          Enables or disables exceptions.
static void setLogLevel(jcuda.LogLevel logLevel)
          Set the specified log level for the JCublas library.
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Method Detail

initialize

public static void initialize()
Initializes the native library. Note that this method does not have to be called explicitly, since it will be called automatically when this class is loaded.


setLogLevel

public static void setLogLevel(jcuda.LogLevel logLevel)
Set the specified log level for the JCublas library.

Currently supported log levels:
LOG_QUIET: Never print anything
LOG_ERROR: Print error messages
LOG_TRACE: Print a trace of all native function calls

Parameters:
logLevel - The log level to use.

setExceptionsEnabled

public static void setExceptionsEnabled(boolean enabled)
Enables or disables exceptions. By default, the methods of this class only return the cublasStatus from the native method. If exceptions are enabled, a CudaException with a detailed error message will be thrown if a method is about to return a result code that is not cublasStatus.CUBLAS_STATUS_SUCCESS

Parameters:
enabled - Whether exceptions are enabled

cublasCreate

public static int cublasCreate(cublasHandle handle)

cublasDestroy

public static int cublasDestroy(cublasHandle handle)

cublasGetVersion

public static int cublasGetVersion(cublasHandle handle,
                                   int[] version)

cublasSetStream

public static int cublasSetStream(cublasHandle handle,
                                  jcuda.runtime.cudaStream_t streamId)

cublasGetStream

public static int cublasGetStream(cublasHandle handle,
                                  jcuda.runtime.cudaStream_t streamId)

cublasGetPointerMode

public static int cublasGetPointerMode(cublasHandle handle,
                                       int[] mode)

cublasSetPointerMode

public static int cublasSetPointerMode(cublasHandle handle,
                                       int mode)

cublasGetAtomicsMode

public static int cublasGetAtomicsMode(cublasHandle handle,
                                       int[] mode)

cublasSetAtomicsMode

public static int cublasSetAtomicsMode(cublasHandle handle,
                                       int mode)

cublasSetVector

public static int cublasSetVector(int n,
                                  int elemSize,
                                  jcuda.Pointer x,
                                  int incx,
                                  jcuda.Pointer devicePtr,
                                  int incy)
 cublasStatus_t 
 cublasSetVector (int n, int elemSize, const void *x, int incx, 
                  void *y, int incy) 

 copies n elements from a vector x in CPU memory space to a vector y 
 in GPU memory space. Elements in both vectors are assumed to have a 
 size of elemSize bytes. Storage spacing between consecutive elements
 is incx for the source vector x and incy for the destination vector
 y. In general, y points to an object, or part of an object, allocated
 via cublasAlloc(). Column major format for two-dimensional matrices
 is assumed throughout CUBLAS. Therefore, if the increment for a vector 
 is equal to 1, this access a column vector while using an increment 
 equal to the leading dimension of the respective matrix accesses a 
 row vector.

 Return Values
 -------------
 CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized
 CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0
 CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory   
 CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 


cublasGetVector

public static int cublasGetVector(int n,
                                  int elemSize,
                                  jcuda.Pointer x,
                                  int incx,
                                  jcuda.Pointer y,
                                  int incy)
 cublasStatus_t 
 cublasGetVector (int n, int elemSize, const void *x, int incx, 
                  void *y, int incy)
 
 copies n elements from a vector x in GPU memory space to a vector y 
 in CPU memory space. Elements in both vectors are assumed to have a 
 size of elemSize bytes. Storage spacing between consecutive elements
 is incx for the source vector x and incy for the destination vector
 y. In general, x points to an object, or part of an object, allocated
 via cublasAlloc(). Column major format for two-dimensional matrices
 is assumed throughout CUBLAS. Therefore, if the increment for a vector 
 is equal to 1, this access a column vector while using an increment 
 equal to the leading dimension of the respective matrix accesses a 
 row vector.

 Return Values
 -------------
 CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized
 CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0
 CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory   
 CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 


cublasSetMatrix

public static int cublasSetMatrix(int rows,
                                  int cols,
                                  int elemSize,
                                  jcuda.Pointer A,
                                  int lda,
                                  jcuda.Pointer B,
                                  int ldb)
 cublasStatus_t 
 cublasSetMatrix (int rows, int cols, int elemSize, const void *A, 
                  int lda, void *B, int ldb)

 copies a tile of rows x cols elements from a matrix A in CPU memory
 space to a matrix B in GPU memory space. Each element requires storage
 of elemSize bytes. Both matrices are assumed to be stored in column 
 major format, with the leading dimension (i.e. number of rows) of 
 source matrix A provided in lda, and the leading dimension of matrix B
 provided in ldb. In general, B points to an object, or part of an 
 object, that was allocated via cublasAlloc().

 Return Values 
 -------------
 CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized
 CUBLAS_STATUS_INVALID_VALUE    if rows or cols < 0, or elemSize, lda, or 
                                ldb <= 0
 CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory
 CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 


cublasGetMatrix

public static int cublasGetMatrix(int rows,
                                  int cols,
                                  int elemSize,
                                  jcuda.Pointer A,
                                  int lda,
                                  jcuda.Pointer B,
                                  int ldb)
 cublasStatus_t 
 cublasGetMatrix (int rows, int cols, int elemSize, const void *A, 
                  int lda, void *B, int ldb)

 copies a tile of rows x cols elements from a matrix A in GPU memory
 space to a matrix B in CPU memory space. Each element requires storage
 of elemSize bytes. Both matrices are assumed to be stored in column 
 major format, with the leading dimension (i.e. number of rows) of 
 source matrix A provided in lda, and the leading dimension of matrix B
 provided in ldb. In general, A points to an object, or part of an 
 object, that was allocated via cublasAlloc().

 Return Values 
 -------------
 CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized
 CUBLAS_STATUS_INVALID_VALUE    if rows, cols, eleSize, lda, or ldb <= 0
 CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory
 CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 


cublasSetVectorAsync

public static int cublasSetVectorAsync(int n,
                                       int elemSize,
                                       jcuda.Pointer hostPtr,
                                       int incx,
                                       jcuda.Pointer devicePtr,
                                       int incy,
                                       jcuda.runtime.cudaStream_t stream)
 cublasStatus 
 cublasSetVectorAsync ( int n, int elemSize, const void *x, int incx, 
                       void *y, int incy, cudaStream_t stream );

 cublasSetVectorAsync has the same functionnality as cublasSetVector
 but the transfer is done asynchronously within the CUDA stream passed
 in parameter.

 Return Values
 -------------
 CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized
 CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0
 CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory   
 CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 


cublasGetVectorAsync

public static int cublasGetVectorAsync(int n,
                                       int elemSize,
                                       jcuda.Pointer devicePtr,
                                       int incx,
                                       jcuda.Pointer hostPtr,
                                       int incy,
                                       jcuda.runtime.cudaStream_t stream)
 cublasStatus 
 cublasGetVectorAsync( int n, int elemSize, const void *x, int incx, 
                       void *y, int incy, cudaStream_t stream)
 
 cublasGetVectorAsync has the same functionnality as cublasGetVector
 but the transfer is done asynchronously within the CUDA stream passed
 in parameter.

 Return Values
 -------------
 CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized
 CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0
 CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory   
 CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 


cublasSetMatrixAsync

public static int cublasSetMatrixAsync(int rows,
                                       int cols,
                                       int elemSize,
                                       jcuda.Pointer A,
                                       int lda,
                                       jcuda.Pointer B,
                                       int ldb,
                                       jcuda.runtime.cudaStream_t stream)
 cublasStatus_t 
 cublasSetMatrixAsync (int rows, int cols, int elemSize, const void *A, 
                       int lda, void *B, int ldb, cudaStream_t stream)

 cublasSetMatrixAsync has the same functionnality as cublasSetMatrix
 but the transfer is done asynchronously within the CUDA stream passed
 in parameter.

 Return Values 
 -------------
 CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized
 CUBLAS_STATUS_INVALID_VALUE    if rows or cols < 0, or elemSize, lda, or 
                                ldb <= 0
 CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory
 CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 


cublasGetMatrixAsync

public static int cublasGetMatrixAsync(int rows,
                                       int cols,
                                       int elemSize,
                                       jcuda.Pointer A,
                                       int lda,
                                       jcuda.Pointer B,
                                       int ldb,
                                       jcuda.runtime.cudaStream_t stream)
 cublasStatus_t 
 cublasGetMatrixAsync (int rows, int cols, int elemSize, const void *A, 
                       int lda, void *B, int ldb, cudaStream_t stream)

 cublasGetMatrixAsync has the same functionnality as cublasGetMatrix
 but the transfer is done asynchronously within the CUDA stream passed
 in parameter.

 Return Values 
 -------------
 CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized
 CUBLAS_STATUS_INVALID_VALUE    if rows, cols, eleSize, lda, or ldb <= 0
 CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory
 CUBLAS_STATUS_SUCCESS          if the operation completed successfully
 


cublasXerbla

public static void cublasXerbla(byte[] srName,
                                int info)

cublasSnrm2

public static int cublasSnrm2(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer result)

cublasDnrm2

public static int cublasDnrm2(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer result)
host or device pointer


cublasScnrm2

public static int cublasScnrm2(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)
host or device pointer


cublasDznrm2

public static int cublasDznrm2(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)
host or device pointer


cublasSdot

public static int cublasSdot(cublasHandle handle,
                             int n,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer y,
                             int incy,
                             jcuda.Pointer result)
host or device pointer


cublasDdot

public static int cublasDdot(cublasHandle handle,
                             int n,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer y,
                             int incy,
                             jcuda.Pointer result)
host or device pointer


cublasCdotu

public static int cublasCdotu(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer result)
host or device pointer


cublasCdotc

public static int cublasCdotc(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer result)
host or device pointer


cublasZdotu

public static int cublasZdotu(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer result)
host or device pointer


cublasZdotc

public static int cublasZdotc(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer result)
host or device pointer


cublasSscal

public static int cublasSscal(cublasHandle handle,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx)
host or device pointer


cublasDscal

public static int cublasDscal(cublasHandle handle,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx)

cublasCscal

public static int cublasCscal(cublasHandle handle,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx)

cublasCsscal

public static int cublasCsscal(cublasHandle handle,
                               int n,
                               jcuda.Pointer alpha,
                               jcuda.Pointer x,
                               int incx)

cublasZscal

public static int cublasZscal(cublasHandle handle,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx)

cublasZdscal

public static int cublasZdscal(cublasHandle handle,
                               int n,
                               jcuda.Pointer alpha,
                               jcuda.Pointer x,
                               int incx)

cublasSaxpy

public static int cublasSaxpy(cublasHandle handle,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasDaxpy

public static int cublasDaxpy(cublasHandle handle,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasCaxpy

public static int cublasCaxpy(cublasHandle handle,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasZaxpy

public static int cublasZaxpy(cublasHandle handle,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasScopy

public static int cublasScopy(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasDcopy

public static int cublasDcopy(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasCcopy

public static int cublasCcopy(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasZcopy

public static int cublasZcopy(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasSswap

public static int cublasSswap(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasDswap

public static int cublasDswap(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasCswap

public static int cublasCswap(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasZswap

public static int cublasZswap(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy)

cublasIsamax

public static int cublasIsamax(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)

cublasIdamax

public static int cublasIdamax(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)
host or device pointer


cublasIcamax

public static int cublasIcamax(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)
host or device pointer


cublasIzamax

public static int cublasIzamax(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)
host or device pointer


cublasIsamin

public static int cublasIsamin(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)
host or device pointer


cublasIdamin

public static int cublasIdamin(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)
host or device pointer


cublasIcamin

public static int cublasIcamin(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)
host or device pointer


cublasIzamin

public static int cublasIzamin(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)
host or device pointer


cublasSasum

public static int cublasSasum(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer result)
host or device pointer


cublasDasum

public static int cublasDasum(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer result)
host or device pointer


cublasScasum

public static int cublasScasum(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)
host or device pointer


cublasDzasum

public static int cublasDzasum(cublasHandle handle,
                               int n,
                               jcuda.Pointer x,
                               int incx,
                               jcuda.Pointer result)
host or device pointer


cublasSrot

public static int cublasSrot(cublasHandle handle,
                             int n,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer y,
                             int incy,
                             jcuda.Pointer c,
                             jcuda.Pointer s)
host or device pointer


cublasDrot

public static int cublasDrot(cublasHandle handle,
                             int n,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer y,
                             int incy,
                             jcuda.Pointer c,
                             jcuda.Pointer s)
host or device pointer


cublasCrot

public static int cublasCrot(cublasHandle handle,
                             int n,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer y,
                             int incy,
                             jcuda.Pointer c,
                             jcuda.Pointer s)
host or device pointer


cublasCsrot

public static int cublasCsrot(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer c,
                              jcuda.Pointer s)
host or device pointer


cublasZrot

public static int cublasZrot(cublasHandle handle,
                             int n,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer y,
                             int incy,
                             jcuda.Pointer c,
                             jcuda.Pointer s)
host or device pointer


cublasZdrot

public static int cublasZdrot(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer c,
                              jcuda.Pointer s)
host or device pointer


cublasSrotg

public static int cublasSrotg(cublasHandle handle,
                              jcuda.Pointer a,
                              jcuda.Pointer b,
                              jcuda.Pointer c,
                              jcuda.Pointer s)
host or device pointer


cublasDrotg

public static int cublasDrotg(cublasHandle handle,
                              jcuda.Pointer a,
                              jcuda.Pointer b,
                              jcuda.Pointer c,
                              jcuda.Pointer s)
host or device pointer


cublasCrotg

public static int cublasCrotg(cublasHandle handle,
                              jcuda.Pointer a,
                              jcuda.Pointer b,
                              jcuda.Pointer c,
                              jcuda.Pointer s)
host or device pointer


cublasZrotg

public static int cublasZrotg(cublasHandle handle,
                              jcuda.Pointer a,
                              jcuda.Pointer b,
                              jcuda.Pointer c,
                              jcuda.Pointer s)
host or device pointer


cublasSrotm

public static int cublasSrotm(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer param)
host or device pointer


cublasDrotm

public static int cublasDrotm(cublasHandle handle,
                              int n,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer param)
host or device pointer


cublasSrotmg

public static int cublasSrotmg(cublasHandle handle,
                               jcuda.Pointer d1,
                               jcuda.Pointer d2,
                               jcuda.Pointer x1,
                               jcuda.Pointer y1,
                               jcuda.Pointer param)
host or device pointer


cublasDrotmg

public static int cublasDrotmg(cublasHandle handle,
                               jcuda.Pointer d1,
                               jcuda.Pointer d2,
                               jcuda.Pointer x1,
                               jcuda.Pointer y1,
                               jcuda.Pointer param)
host or device pointer


cublasSgemv

public static int cublasSgemv(cublasHandle handle,
                              int trans,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)
host or device pointer


cublasDgemv

public static int cublasDgemv(cublasHandle handle,
                              int trans,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasCgemv

public static int cublasCgemv(cublasHandle handle,
                              int trans,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasZgemv

public static int cublasZgemv(cublasHandle handle,
                              int trans,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasSgbmv

public static int cublasSgbmv(cublasHandle handle,
                              int trans,
                              int m,
                              int n,
                              int kl,
                              int ku,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasDgbmv

public static int cublasDgbmv(cublasHandle handle,
                              int trans,
                              int m,
                              int n,
                              int kl,
                              int ku,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasCgbmv

public static int cublasCgbmv(cublasHandle handle,
                              int trans,
                              int m,
                              int n,
                              int kl,
                              int ku,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasZgbmv

public static int cublasZgbmv(cublasHandle handle,
                              int trans,
                              int m,
                              int n,
                              int kl,
                              int ku,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasStrmv

public static int cublasStrmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasDtrmv

public static int cublasDtrmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasCtrmv

public static int cublasCtrmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasZtrmv

public static int cublasZtrmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasStbmv

public static int cublasStbmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              int k,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasDtbmv

public static int cublasDtbmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              int k,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasCtbmv

public static int cublasCtbmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              int k,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasZtbmv

public static int cublasZtbmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              int k,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasStpmv

public static int cublasStpmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx)

cublasDtpmv

public static int cublasDtpmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx)

cublasCtpmv

public static int cublasCtpmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx)

cublasZtpmv

public static int cublasZtpmv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx)

cublasStrsv

public static int cublasStrsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasDtrsv

public static int cublasDtrsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasCtrsv

public static int cublasCtrsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasZtrsv

public static int cublasZtrsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasStpsv

public static int cublasStpsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx)

cublasDtpsv

public static int cublasDtpsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx)

cublasCtpsv

public static int cublasCtpsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx)

cublasZtpsv

public static int cublasZtpsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx)

cublasStbsv

public static int cublasStbsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              int k,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasDtbsv

public static int cublasDtbsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              int k,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasCtbsv

public static int cublasCtbsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              int k,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasZtbsv

public static int cublasZtbsv(cublasHandle handle,
                              int uplo,
                              int trans,
                              int diag,
                              int n,
                              int k,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx)

cublasSsymv

public static int cublasSsymv(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasDsymv

public static int cublasDsymv(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasCsymv

public static int cublasCsymv(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasZsymv

public static int cublasZsymv(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasChemv

public static int cublasChemv(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasZhemv

public static int cublasZhemv(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasSsbmv

public static int cublasSsbmv(cublasHandle handle,
                              int uplo,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasDsbmv

public static int cublasDsbmv(cublasHandle handle,
                              int uplo,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasChbmv

public static int cublasChbmv(cublasHandle handle,
                              int uplo,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasZhbmv

public static int cublasZhbmv(cublasHandle handle,
                              int uplo,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasSspmv

public static int cublasSspmv(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasDspmv

public static int cublasDspmv(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasChpmv

public static int cublasChpmv(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasZhpmv

public static int cublasZhpmv(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer AP,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer beta,
                              jcuda.Pointer y,
                              int incy)

cublasSger

public static int cublasSger(cublasHandle handle,
                             int m,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer y,
                             int incy,
                             jcuda.Pointer A,
                             int lda)

cublasDger

public static int cublasDger(cublasHandle handle,
                             int m,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer y,
                             int incy,
                             jcuda.Pointer A,
                             int lda)

cublasCgeru

public static int cublasCgeru(cublasHandle handle,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer A,
                              int lda)

cublasCgerc

public static int cublasCgerc(cublasHandle handle,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer A,
                              int lda)

cublasZgeru

public static int cublasZgeru(cublasHandle handle,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer A,
                              int lda)

cublasZgerc

public static int cublasZgerc(cublasHandle handle,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer A,
                              int lda)

cublasSsyr

public static int cublasSsyr(cublasHandle handle,
                             int uplo,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer A,
                             int lda)

cublasDsyr

public static int cublasDsyr(cublasHandle handle,
                             int uplo,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer A,
                             int lda)

cublasCsyr

public static int cublasCsyr(cublasHandle handle,
                             int uplo,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer A,
                             int lda)

cublasZsyr

public static int cublasZsyr(cublasHandle handle,
                             int uplo,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer A,
                             int lda)

cublasCher

public static int cublasCher(cublasHandle handle,
                             int uplo,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer A,
                             int lda)

cublasZher

public static int cublasZher(cublasHandle handle,
                             int uplo,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer A,
                             int lda)

cublasSspr

public static int cublasSspr(cublasHandle handle,
                             int uplo,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer AP)

cublasDspr

public static int cublasDspr(cublasHandle handle,
                             int uplo,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer AP)

cublasChpr

public static int cublasChpr(cublasHandle handle,
                             int uplo,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer AP)

cublasZhpr

public static int cublasZhpr(cublasHandle handle,
                             int uplo,
                             int n,
                             jcuda.Pointer alpha,
                             jcuda.Pointer x,
                             int incx,
                             jcuda.Pointer AP)

cublasSsyr2

public static int cublasSsyr2(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer A,
                              int lda)

cublasDsyr2

public static int cublasDsyr2(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer A,
                              int lda)

cublasCsyr2

public static int cublasCsyr2(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer A,
                              int lda)

cublasZsyr2

public static int cublasZsyr2(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer A,
                              int lda)

cublasCher2

public static int cublasCher2(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer A,
                              int lda)

cublasZher2

public static int cublasZher2(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer A,
                              int lda)

cublasSspr2

public static int cublasSspr2(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer AP)

cublasDspr2

public static int cublasDspr2(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer AP)

cublasChpr2

public static int cublasChpr2(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer AP)

cublasZhpr2

public static int cublasZhpr2(cublasHandle handle,
                              int uplo,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer y,
                              int incy,
                              jcuda.Pointer AP)

cublasSgemm

public static int cublasSgemm(cublasHandle handle,
                              int transa,
                              int transb,
                              int m,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasDgemm

public static int cublasDgemm(cublasHandle handle,
                              int transa,
                              int transb,
                              int m,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasCgemm

public static int cublasCgemm(cublasHandle handle,
                              int transa,
                              int transb,
                              int m,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasZgemm

public static int cublasZgemm(cublasHandle handle,
                              int transa,
                              int transb,
                              int m,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasSsyrk

public static int cublasSsyrk(cublasHandle handle,
                              int uplo,
                              int trans,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasDsyrk

public static int cublasDsyrk(cublasHandle handle,
                              int uplo,
                              int trans,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasCsyrk

public static int cublasCsyrk(cublasHandle handle,
                              int uplo,
                              int trans,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasZsyrk

public static int cublasZsyrk(cublasHandle handle,
                              int uplo,
                              int trans,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasCherk

public static int cublasCherk(cublasHandle handle,
                              int uplo,
                              int trans,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasZherk

public static int cublasZherk(cublasHandle handle,
                              int uplo,
                              int trans,
                              int n,
                              int k,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasSsyr2k

public static int cublasSsyr2k(cublasHandle handle,
                               int uplo,
                               int trans,
                               int n,
                               int k,
                               jcuda.Pointer alpha,
                               jcuda.Pointer A,
                               int lda,
                               jcuda.Pointer B,
                               int ldb,
                               jcuda.Pointer beta,
                               jcuda.Pointer C,
                               int ldc)

cublasDsyr2k

public static int cublasDsyr2k(cublasHandle handle,
                               int uplo,
                               int trans,
                               int n,
                               int k,
                               jcuda.Pointer alpha,
                               jcuda.Pointer A,
                               int lda,
                               jcuda.Pointer B,
                               int ldb,
                               jcuda.Pointer beta,
                               jcuda.Pointer C,
                               int ldc)

cublasCsyr2k

public static int cublasCsyr2k(cublasHandle handle,
                               int uplo,
                               int trans,
                               int n,
                               int k,
                               jcuda.Pointer alpha,
                               jcuda.Pointer A,
                               int lda,
                               jcuda.Pointer B,
                               int ldb,
                               jcuda.Pointer beta,
                               jcuda.Pointer C,
                               int ldc)

cublasZsyr2k

public static int cublasZsyr2k(cublasHandle handle,
                               int uplo,
                               int trans,
                               int n,
                               int k,
                               jcuda.Pointer alpha,
                               jcuda.Pointer A,
                               int lda,
                               jcuda.Pointer B,
                               int ldb,
                               jcuda.Pointer beta,
                               jcuda.Pointer C,
                               int ldc)

cublasCher2k

public static int cublasCher2k(cublasHandle handle,
                               int uplo,
                               int trans,
                               int n,
                               int k,
                               jcuda.Pointer alpha,
                               jcuda.Pointer A,
                               int lda,
                               jcuda.Pointer B,
                               int ldb,
                               jcuda.Pointer beta,
                               jcuda.Pointer C,
                               int ldc)

cublasZher2k

public static int cublasZher2k(cublasHandle handle,
                               int uplo,
                               int trans,
                               int n,
                               int k,
                               jcuda.Pointer alpha,
                               jcuda.Pointer A,
                               int lda,
                               jcuda.Pointer B,
                               int ldb,
                               jcuda.Pointer beta,
                               jcuda.Pointer C,
                               int ldc)

cublasSsymm

public static int cublasSsymm(cublasHandle handle,
                              int side,
                              int uplo,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasDsymm

public static int cublasDsymm(cublasHandle handle,
                              int side,
                              int uplo,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasCsymm

public static int cublasCsymm(cublasHandle handle,
                              int side,
                              int uplo,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasZsymm

public static int cublasZsymm(cublasHandle handle,
                              int side,
                              int uplo,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasChemm

public static int cublasChemm(cublasHandle handle,
                              int side,
                              int uplo,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasZhemm

public static int cublasZhemm(cublasHandle handle,
                              int side,
                              int uplo,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer beta,
                              jcuda.Pointer C,
                              int ldc)

cublasStrsm

public static int cublasStrsm(cublasHandle handle,
                              int side,
                              int uplo,
                              int trans,
                              int diag,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb)

cublasDtrsm

public static int cublasDtrsm(cublasHandle handle,
                              int side,
                              int uplo,
                              int trans,
                              int diag,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb)

cublasCtrsm

public static int cublasCtrsm(cublasHandle handle,
                              int side,
                              int uplo,
                              int trans,
                              int diag,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb)

cublasZtrsm

public static int cublasZtrsm(cublasHandle handle,
                              int side,
                              int uplo,
                              int trans,
                              int diag,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb)

cublasStrmm

public static int cublasStrmm(cublasHandle handle,
                              int side,
                              int uplo,
                              int trans,
                              int diag,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer C,
                              int ldc)

cublasDtrmm

public static int cublasDtrmm(cublasHandle handle,
                              int side,
                              int uplo,
                              int trans,
                              int diag,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer C,
                              int ldc)

cublasCtrmm

public static int cublasCtrmm(cublasHandle handle,
                              int side,
                              int uplo,
                              int trans,
                              int diag,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer C,
                              int ldc)

cublasZtrmm

public static int cublasZtrmm(cublasHandle handle,
                              int side,
                              int uplo,
                              int trans,
                              int diag,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer C,
                              int ldc)

cublasSgemmBatched

public static int cublasSgemmBatched(cublasHandle handle,
                                     int transa,
                                     int transb,
                                     int m,
                                     int n,
                                     int k,
                                     jcuda.Pointer alpha,
                                     jcuda.Pointer Aarray,
                                     int lda,
                                     jcuda.Pointer Barray,
                                     int ldb,
                                     jcuda.Pointer beta,
                                     jcuda.Pointer Carray,
                                     int ldc,
                                     int batchCount)

cublasDgemmBatched

public static int cublasDgemmBatched(cublasHandle handle,
                                     int transa,
                                     int transb,
                                     int m,
                                     int n,
                                     int k,
                                     jcuda.Pointer alpha,
                                     jcuda.Pointer Aarray,
                                     int lda,
                                     jcuda.Pointer Barray,
                                     int ldb,
                                     jcuda.Pointer beta,
                                     jcuda.Pointer Carray,
                                     int ldc,
                                     int batchCount)

cublasCgemmBatched

public static int cublasCgemmBatched(cublasHandle handle,
                                     int transa,
                                     int transb,
                                     int m,
                                     int n,
                                     int k,
                                     jcuda.Pointer alpha,
                                     jcuda.Pointer Aarray,
                                     int lda,
                                     jcuda.Pointer Barray,
                                     int ldb,
                                     jcuda.Pointer beta,
                                     jcuda.Pointer Carray,
                                     int ldc,
                                     int batchCount)

cublasZgemmBatched

public static int cublasZgemmBatched(cublasHandle handle,
                                     int transa,
                                     int transb,
                                     int m,
                                     int n,
                                     int k,
                                     jcuda.Pointer alpha,
                                     jcuda.Pointer Aarray,
                                     int lda,
                                     jcuda.Pointer Barray,
                                     int ldb,
                                     jcuda.Pointer beta,
                                     jcuda.Pointer Carray,
                                     int ldc,
                                     int batchCount)

cublasSgeam

public static int cublasSgeam(cublasHandle handle,
                              int transa,
                              int transb,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer beta,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer C,
                              int ldc)

cublasDgeam

public static int cublasDgeam(cublasHandle handle,
                              int transa,
                              int transb,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer beta,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer C,
                              int ldc)

cublasCgeam

public static int cublasCgeam(cublasHandle handle,
                              int transa,
                              int transb,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer beta,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer C,
                              int ldc)

cublasZgeam

public static int cublasZgeam(cublasHandle handle,
                              int transa,
                              int transb,
                              int m,
                              int n,
                              jcuda.Pointer alpha,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer beta,
                              jcuda.Pointer B,
                              int ldb,
                              jcuda.Pointer C,
                              int ldc)

cublasSgetrfBatched

public static int cublasSgetrfBatched(cublasHandle handle,
                                      int n,
                                      jcuda.Pointer A,
                                      int lda,
                                      jcuda.Pointer P,
                                      jcuda.Pointer INFO,
                                      int batchSize)

cublasDgetrfBatched

public static int cublasDgetrfBatched(cublasHandle handle,
                                      int n,
                                      jcuda.Pointer A,
                                      int lda,
                                      jcuda.Pointer P,
                                      jcuda.Pointer INFO,
                                      int batchSize)

cublasCgetrfBatched

public static int cublasCgetrfBatched(cublasHandle handle,
                                      int n,
                                      jcuda.Pointer A,
                                      int lda,
                                      jcuda.Pointer P,
                                      jcuda.Pointer INFO,
                                      int batchSize)

cublasZgetrfBatched

public static int cublasZgetrfBatched(cublasHandle handle,
                                      int n,
                                      jcuda.Pointer A,
                                      int lda,
                                      jcuda.Pointer P,
                                      jcuda.Pointer INFO,
                                      int batchSize)

cublasStrsmBatched

public static int cublasStrsmBatched(cublasHandle handle,
                                     int side,
                                     int uplo,
                                     int trans,
                                     int diag,
                                     int m,
                                     int n,
                                     jcuda.Pointer alpha,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer B,
                                     int ldb,
                                     int batchCount)

cublasDtrsmBatched

public static int cublasDtrsmBatched(cublasHandle handle,
                                     int side,
                                     int uplo,
                                     int trans,
                                     int diag,
                                     int m,
                                     int n,
                                     jcuda.Pointer alpha,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer B,
                                     int ldb,
                                     int batchCount)

cublasCtrsmBatched

public static int cublasCtrsmBatched(cublasHandle handle,
                                     int side,
                                     int uplo,
                                     int trans,
                                     int diag,
                                     int m,
                                     int n,
                                     jcuda.Pointer alpha,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer B,
                                     int ldb,
                                     int batchCount)

cublasZtrsmBatched

public static int cublasZtrsmBatched(cublasHandle handle,
                                     int side,
                                     int uplo,
                                     int trans,
                                     int diag,
                                     int m,
                                     int n,
                                     jcuda.Pointer alpha,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer B,
                                     int ldb,
                                     int batchCount)

cublasSdgmm

public static int cublasSdgmm(cublasHandle handle,
                              int mode,
                              int m,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer C,
                              int ldc)

cublasDdgmm

public static int cublasDdgmm(cublasHandle handle,
                              int mode,
                              int m,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer C,
                              int ldc)

cublasCdgmm

public static int cublasCdgmm(cublasHandle handle,
                              int mode,
                              int m,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer C,
                              int ldc)

cublasZdgmm

public static int cublasZdgmm(cublasHandle handle,
                              int mode,
                              int m,
                              int n,
                              jcuda.Pointer A,
                              int lda,
                              jcuda.Pointer x,
                              int incx,
                              jcuda.Pointer C,
                              int ldc)