Uses of Class
jcuda.Pointer

Packages that use Pointer

jcuda	Contains common classes for all JCuda libraries.
jcuda.driver	Contains the classes related to the JCuda driver API.
jcuda.jcublas	Contains the classes of JCublas.
jcuda.jcudpp	Contains the classes of JCudpp.
jcuda.jcufft	Contains the classes of JCufft.
jcuda.runtime	Contains the classes related to the JCuda runtime API.

Uses of Pointer in jcuda

Methods in jcuda that return Pointer

static Pointer	Pointer.to(java.nio.Buffer buffer) Creates a new Pointer to the given Buffer.
static Pointer	Pointer.to(byte[] values) Creates a new Pointer to the given values.
static Pointer	Pointer.to(char[] values) Creates a new Pointer to the given values.
static Pointer	Pointer.to(double[] values) Creates a new Pointer to the given values.
static Pointer	Pointer.to(float[] values) Creates a new Pointer to the given values.
static Pointer	Pointer.to(int[] values) Creates a new Pointer to the given values.
static Pointer	Pointer.to(long[] values) Creates a new Pointer to the given values.
static Pointer	Pointer.to(Pointer... pointers) Creates a new Pointer to the given Pointers.
static Pointer	Pointer.to(short[] values) Creates a new Pointer to the given values.
Pointer	Pointer.withByteOffset(long byteOffset) Returns a new pointer with an offset of the given number of bytes

Methods in jcuda with parameters of type Pointer

static Pointer

Pointer.to(Pointer... pointers) Creates a new Pointer to the given Pointers.

Uses of Pointer in jcuda.driver

Methods in jcuda.driver with parameters of type Pointer

static int	JCudaDriver.cuMemAllocHost(Pointer pp, int bytesize) Allocates page-locked host memory.
static int	JCudaDriver.cuMemcpyAtoH(Pointer dstHost, jcuda.driver.CUarray srcArray, int srcIndex, int ByteCount) Copies memory from Array to Host.
static int	JCudaDriver.cuMemcpyAtoHAsync(Pointer dstHost, jcuda.driver.CUarray srcArray, int srcIndex, int ByteCount, jcuda.driver.CUstream hStream) Copies memory.
static int	JCudaDriver.cuMemcpyDtoH(Pointer dstHost, jcuda.driver.CUdeviceptr srcDevice, int ByteCount) Copies memory from Device to Host.
static int	JCudaDriver.cuMemcpyDtoHAsync(Pointer dstHost, jcuda.driver.CUdeviceptr srcDevice, int ByteCount, jcuda.driver.CUstream hStream) Copies memory.
static int	JCudaDriver.cuMemcpyHtoA(jcuda.driver.CUarray dstArray, int dstIndex, Pointer pSrc, int ByteCount) Copies memory from Host to Array.
static int	JCudaDriver.cuMemcpyHtoAAsync(jcuda.driver.CUarray dstArray, int dstIndex, Pointer pSrc, int ByteCount, jcuda.driver.CUstream hStream) Copies memory.
static int	JCudaDriver.cuMemcpyHtoD(jcuda.driver.CUdeviceptr dstDevice, Pointer srcHost, int ByteCount) Copy memory from Host to Device.
static int	JCudaDriver.cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr dstDevice, Pointer srcHost, int ByteCount, jcuda.driver.CUstream hStream) Copies memory.
static int	JCudaDriver.cuMemFreeHost(Pointer p) Frees page-locked host memory.
static int	JCudaDriver.cuMemHostAlloc(Pointer pp, long bytes, int Flags) Allocates bytes bytes of host memory that is page-locked and accessible to the device.
static int	JCudaDriver.cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr ret, Pointer p, int Flags) Passes back the device pointer ret corresponding to the mapped, pinned host buffer p allocated by cuMemHostAlloc.
static int	JCudaDriver.cuMemHostGetFlags(int[] pFlags, Pointer p) Passes back the flags pFlags that were specified when allocating the pinned host buffer p allocated by cuMemHostAlloc.
static int	JCudaDriver.cuModuleLoadDataEx(jcuda.driver.CUmodule phMod, Pointer p, int numOptions, int[] options, Pointer optionValues) Takes a pointer p and loads the corresponding module phMod into the current context.
static int	JCudaDriver.cuParamSetv(jcuda.driver.CUfunction hfunc, int offset, Pointer ptr, int numbytes) Adds arbitrary data to the function�s argument list.

Uses of Pointer in jcuda.jcublas

Methods in jcuda.jcublas with parameters of type Pointer

static int	JCublas.cublasAlloc(int n, int elemSize, Pointer ptr) Wrapper for CUBLAS function. cublasStatus cublasAlloc (int n, int elemSize, void **devicePtr) creates an object in GPU memory space capable of holding an array of n elements, where each element requires elemSize bytes of storage.
static void	JCublas.cublasCaxpy(int n, cuComplex alpha, Pointer x, int incx, Pointer y, int incy) void cublasCaxpy (int n, cuComplex alpha, const cuComplex *x, int incx, cuComplex *y, int incy) multiplies single-complex vector x by single-complex scalar alpha and adds the result to single-complex vector y; that is, it overwrites single-complex y with single-complex alpha * x + y.
static void	JCublas.cublasCcopy(int n, Pointer x, int incx, Pointer y, int incy) void cublasCcopy (int n, const cuComplex *x, int incx, cuComplex *y, int incy) copies the single-complex vector x to the single-complex vector y.
static void	JCublas.cublasCgbmv(char trans, int m, int n, int kl, int ku, cuComplex alpha, Pointer A, int lda, Pointer x, int incx, cuComplex beta, Pointer y, int incy) void cublasCgbmv (char trans, int m, int n, int kl, int ku, cuComplex alpha, const cuComplex *A, int lda, const cuComplex *x, int incx, cuComplex beta, cuComplex *y, int incy); performs one of the matrix-vector operations y = alpha*op(A)*x + beta*y, op(A)=A or op(A) = transpose(A) alpha and beta are single precision complex scalars.
static void	JCublas.cublasCgemm(char transa, char transb, int m, int n, int k, cuComplex alpha, Pointer A, int lda, Pointer B, int ldb, cuComplex beta, Pointer C, int ldc) void cublasCgemm (char transa, char transb, int m, int n, int k, cuComplex alpha, const cuComplex *A, int lda, const cuComplex *B, int ldb, cuComplex beta, cuComplex *C, int ldc) performs one of the matrix-matrix operations C = alpha * op(A) * op(B) + beta*C, where op(X) is one of op(X) = X or op(X) = transpose or op(X) = conjg(transpose(X)) alpha and beta are single-complex scalars, and A, B and C are matrices consisting of single-complex elements, with op(A) an m x k matrix, op(B) a k x n matrix and C an m x n matrix.
static void	JCublas.cublasCgemv(char trans, int m, int n, cuComplex alpha, Pointer A, int lda, Pointer x, int incx, cuComplex beta, Pointer y, int incy) cublasCgemv (char trans, int m, int n, cuComplex alpha, const cuComplex *A, int lda, const cuComplex *x, int incx, cuComplex beta, cuComplex *y, int incy) performs one of the matrix-vector operations y = alpha * op(A) * x + beta * y, where op(A) is one of op(A) = A or op(A) = transpose(A) or op(A) = conjugate(transpose(A)) where alpha and beta are single precision scalars, x and y are single precision vectors, and A is an m x n matrix consisting of single precision elements.
static void	JCublas.cublasCgerc(int m, int n, cuComplex alpha, Pointer x, int incx, Pointer y, int incy, Pointer A, int lda) cublasCgerc (int m, int n, cuComplex alpha, const cuComplex *x, int incx, const cuComplex *y, int incy, cuComplex *A, int lda) performs the symmetric rank 1 operation A = alpha * x * conjugate(transpose(y)) + A, where alpha is a single precision complex scalar, x is an m element single precision complex vector, y is an n element single precision complex vector, and A is an m by n matrix consisting of single precision complex elements.
static void	JCublas.cublasCgeru(int m, int n, cuComplex alpha, Pointer x, int incx, Pointer y, int incy, Pointer A, int lda) cublasCgeru (int m, int n, cuComplex alpha, const cuComplex *x, int incx, const cuComplex *y, int incy, cuComplex *A, int lda) performs the symmetric rank 1 operation A = alpha * x * transpose(y) + A, where alpha is a single precision complex scalar, x is an m element single precision complex vector, y is an n element single precision complex vector, and A is an m by n matrix consisting of single precision complex elements.
static void	JCublas.cublasChbmv(char uplo, int n, int k, cuComplex alpha, Pointer A, int lda, Pointer x, int incx, cuComplex beta, Pointer y, int incy) void cublasChbmv (char uplo, int n, int k, cuComplex alpha, const cuComplex *A, int lda, const cuComplex *x, int incx, cuComplex beta, cuComplex *y, int incy) performs the matrix-vector operation y := alpha*A*x + beta*y alpha and beta are single precision complex scalars.
static void	JCublas.cublasChemm(char side, char uplo, int m, int n, cuComplex alpha, Pointer A, int lda, Pointer B, int ldb, cuComplex beta, Pointer C, int ldc) void cublasChemm (char side, char uplo, int m, int n, cuComplex alpha, const cuComplex *A, int lda, const cuComplex *B, int ldb, cuComplex beta, cuComplex *C, int ldc); performs one of the matrix-matrix operations C = alpha * A * B + beta * C, or C = alpha * B * A + beta * C, where alpha and beta are single precision complex scalars, A is a hermitian matrix consisting of single precision complex elements and stored in either lower or upper storage mode, and B and C are m x n matrices consisting of single precision complex elements.
static void	JCublas.cublasChemv(char uplo, int n, cuComplex alpha, Pointer A, int lda, Pointer x, int incx, cuComplex beta, Pointer y, int incy) void cublasChemv (char uplo, int n, cuComplex alpha, const cuComplex *A, int lda, const cuComplex *x, int incx, cuComplex beta, cuComplex *y, int incy) performs the matrix-vector operation y = alpha*A*x + beta*y Alpha and beta are single precision complex scalars, and x and y are single precision complex vectors, each with n elements.
static void	JCublas.cublasCher(char uplo, int n, float alpha, Pointer x, int incx, Pointer A, int lda) void cublasCher (char uplo, int n, float alpha, const cuComplex *x, int incx, cuComplex *A, int lda) performs the hermitian rank 1 operation A = alpha * x * conjugate(transpose(x)) + A, where alpha is a single precision real scalar, x is an n element single precision complex vector and A is an n x n hermitian matrix consisting of single precision complex elements.
static void	JCublas.cublasCher2(char uplo, int n, cuComplex alpha, Pointer x, int incx, Pointer y, int incy, Pointer A, int lda) void cublasCher2 (char uplo, int n, cuComplex alpha, const cuComplex *x, int incx, const cuComplex *y, int incy, cuComplex *A, int lda) performs the hermitian rank 2 operation A = alpha*x*conjugate(transpose(y)) + conjugate(alpha)*y*conjugate(transpose(x)) + A, where alpha is a single precision complex scalar, x and y are n element single precision complex vector and A is an n by n hermitian matrix consisting of single precision complex elements.
static void	JCublas.cublasCher2k(char uplo, char trans, int n, int k, cuComplex alpha, Pointer A, int lda, Pointer B, int ldb, float beta, Pointer C, int ldc) void cublasCher2k (char uplo, char trans, int n, int k, cuComplex alpha, const cuComplex *A, int lda, const cuComplex *B, int ldb, float beta, cuComplex *C, int ldc) performs one of the hermitian rank 2k operations C = alpha * A * conjugate(transpose(B)) + conjugate(alpha) * B * conjugate(transpose(A)) + beta * C , or C = alpha * conjugate(transpose(A)) * B + conjugate(alpha) * conjugate(transpose(B)) * A + beta * C.
static void	JCublas.cublasCherk(char uplo, char trans, int n, int k, float alpha, Pointer A, int lda, float beta, Pointer C, int ldc) void cublasCherk (char uplo, char trans, int n, int k, float alpha, const cuComplex *A, int lda, float beta, cuComplex *C, int ldc) performs one of the hermitian rank k operations C = alpha * A * conjugate(transpose(A)) + beta * C, or C = alpha * conjugate(transpose(A)) * A + beta * C.
static void	JCublas.cublasChpr(char uplo, int n, float alpha, Pointer x, int incx, Pointer AP) void cublasChpr (char uplo, int n, float alpha, const cuComplex *x, int incx, cuComplex *AP) performs the hermitian rank 1 operation A = alpha * x * conjugate(transpose(x)) + A, where alpha is a single precision real scalar and x is an n element single precision complex vector.
static void	JCublas.cublasChpr2(char uplo, int n, cuComplex alpha, Pointer x, int incx, Pointer y, int incy, Pointer AP) void cublasChpr2 (char uplo, int n, cuComplex alpha, const cuComplex *x, int incx, const cuComplex *y, int incy, cuComplex *AP) performs the hermitian rank 2 operation A = alpha*x*conjugate(transpose(y)) + conjugate(alpha)*y*conjugate(transpose(x)) + A, where alpha is a single precision complex scalar, and x and y are n element single precision complex vectors.
static void	JCublas.cublasCrot(int n, Pointer x, int incx, Pointer y, int incy, float c, cuComplex s) void cublasCrot (int n, cuComplex *x, int incx, cuComplex *y, int incy, float sc, cuComplex cs) multiplies a 2x2 matrix ( sc cs) with the 2xn matrix ( transpose(x) ) (-conj(cs) sc) ( transpose(y) ) The elements of x are in x[lx + i * incx], i = 0 ...
static void	JCublas.cublasCrotg(Pointer host_ca, cuComplex cb, Pointer host_sc, Pointer host_cs) void cublasCrotg (cuComplex *host_ca, cuComplex cb, float *host_sc, cuComplex *host_cs) constructs the complex Givens tranformation ( sc cs ) G = ( ) , sc^2 + cabs(cs)^2 = 1, (-cs sc ) which zeros the second entry of the complex 2-vector transpose(ca, cb).
static void	JCublas.cublasCscal(int n, cuComplex alpha, Pointer x, int incx) void cublasCscal (int n, cuComplex alpha, cuComplex *x, int incx) replaces single-complex vector x with single-complex alpha * x.
static void	JCublas.cublasCsrot(int n, Pointer x, int incx, Pointer y, int incy, float c, float s) void csrot (int n, cuComplex *x, int incx, cuCumplex *y, int incy, float c, float s) multiplies a 2x2 rotation matrix ( c s) with a 2xn matrix ( transpose(x) ) (-s c) ( transpose(y) ) The elements of x are in x[lx + i * incx], i = 0 ...
static void	JCublas.cublasCsscal(int n, float alpha, Pointer x, int incx) void cublasCsscal (int n, float alpha, cuComplex *x, int incx) replaces single-complex vector x with single-complex alpha * x.
static void	JCublas.cublasCswap(int n, Pointer x, int incx, Pointer y, int incy) void cublasCswap (int n, const cuComplex *x, int incx, cuComplex *y, int incy) interchanges the single-complex vector x with the single-complex vector y.
static void	JCublas.cublasCsymm(char side, char uplo, int m, int n, cuComplex alpha, Pointer A, int lda, Pointer B, int ldb, cuComplex beta, Pointer C, int ldc) void cublasCsymm (char side, char uplo, int m, int n, cuComplex alpha, const cuComplex *A, int lda, const cuComplex *B, int ldb, cuComplex beta, cuComplex *C, int ldc); performs one of the matrix-matrix operations C = alpha * A * B + beta * C, or C = alpha * B * A + beta * C, where alpha and beta are single precision complex scalars, A is a symmetric matrix consisting of single precision complex elements and stored in either lower or upper storage mode, and B and C are m x n matrices consisting of single precision complex elements.
static void	JCublas.cublasCsyr2k(char uplo, char trans, int n, int k, cuComplex alpha, Pointer A, int lda, Pointer B, int ldb, cuComplex beta, Pointer C, int ldc) void cublasCsyr2k (char uplo, char trans, int n, int k, cuComplex alpha, const cuComplex *A, int lda, const cuComplex *B, int ldb, cuComplex beta, cuComplex *C, int ldc) performs one of the symmetric rank 2k operations C = alpha * A * transpose(B) + alpha * B * transpose(A) + beta * C, or C = alpha * transpose(A) * B + alpha * transpose(B) * A + beta * C.
static void	JCublas.cublasCsyrk(char uplo, char trans, int n, int k, cuComplex alpha, Pointer A, int lda, cuComplex beta, Pointer C, int ldc) void cublasCsyrk (char uplo, char trans, int n, int k, cuComplex alpha, const cuComplex *A, int lda, cuComplex beta, cuComplex *C, int ldc) performs one of the symmetric rank k operations C = alpha * A * transpose(A) + beta * C, or C = alpha * transpose(A) * A + beta * C.
static void	JCublas.cublasCtbmv(char uplo, char trans, char diag, int n, int k, Pointer A, int lda, Pointer x, int incx) void cublasCtbmv (char uplo, char trans, char diag, int n, int k, const cuComplex *A, int lda, cuComplex *x, int incx) performs one of the matrix-vector operations x = op(A) * x, where op(A) = A, op(A) = transpose(A) or op(A) = conjugate(transpose(A)).
static void	JCublas.cublasCtbsv(char uplo, char trans, char diag, int n, int k, Pointer A, int lda, Pointer x, int incx) void cublasCtbsv (char uplo, char trans, char diag, int n, int k, const cuComplex *A, int lda, cuComplex *X, int incx) solves one of the systems of equations op(A)*x = b, where op(A) is either op(A) = A , op(A) = transpose(A) or op(A) = conjugate(transpose(A)).
static void	JCublas.cublasCtpmv(char uplo, char trans, char diag, int n, Pointer AP, Pointer x, int incx) void cublasCtpmv (char uplo, char trans, char diag, int n, const cuComplex *AP, cuComplex *x, int incx); performs one of the matrix-vector operations x = op(A) * x, where op(A) = A, op(A) = transpose(A) or op(A) = conjugate(transpose(A)) .
static void	JCublas.cublasCtpsv(char uplo, char trans, char diag, int n, Pointer AP, Pointer x, int incx) void cublasCtpsv (char uplo, char trans, char diag, int n, const cuComplex *AP, cuComplex *X, int incx) solves one of the systems of equations op(A)*x = b, where op(A) is either op(A) = A , op(A) = transpose(A) or op(A) = conjugate(transpose)).
static void	JCublas.cublasCtrmm(char side, char uplo, char transa, char diag, int m, int n, cuComplex alpha, Pointer A, int lda, Pointer B, int ldb) void cublasCtrmm (char side, char uplo, char transa, char diag, int m, int n, cuComplex alpha, const cuComplex *A, int lda, const cuComplex *B, int ldb) performs one of the matrix-matrix operations B = alpha * op(A) * B, or B = alpha * B * op(A) where alpha is a single-precision complex scalar, B is an m x n matrix composed of single precision complex elements, and A is a unit or non-unit, upper or lower, triangular matrix composed of single precision complex elements.
static void	JCublas.cublasCtrmv(char uplo, char trans, char diag, int n, Pointer A, int lda, Pointer x, int incx) cublasCtrmv (char uplo, char trans, char diag, int n, const cuComplex *A, int lda, cuComplex *x, int incx); performs one of the matrix-vector operations x = op(A) * x, where op(A) = A, or op(A) = transpose(A) or op(A) = conjugate(transpose(A)).
static void	JCublas.cublasCtrsm(char side, char uplo, char transa, char diag, int m, int n, cuComplex alpha, Pointer A, int lda, Pointer B, int ldb) void cublasCtrsm (char side, char uplo, char transa, char diag, int m, int n, cuComplex alpha, const cuComplex *A, int lda, cuComplex *B, int ldb) solves one of the matrix equations op(A) * X = alpha * B, or X * op(A) = alpha * B, where alpha is a single precision complex scalar, and X and B are m x n matrices that are composed of single precision complex elements.
static void	JCublas.cublasCtrsv(char uplo, char trans, char diag, int n, Pointer A, int lda, Pointer x, int incx) void cublasCtrsv (char uplo, char trans, char diag, int n, const cuComplex *A, int lda, cuComplex *x, int incx) solves a system of equations op(A) * x = b, where op(A) is either A, transpose(A) or conjugate(transpose(A)).
static double	JCublas.cublasDasum(int n, Pointer x, int incx) double cublasDasum (int n, const double *x, int incx) computes the sum of the absolute values of the elements of double precision vector x; that is, the result is the sum from i = 0 to n - 1 of abs(x[1 + i * incx]).
static void	JCublas.cublasDaxpy(int n, double alpha, Pointer x, int incx, Pointer y, int incy) void cublasDaxpy (int n, double alpha, const double *x, int incx, double *y, int incy) multiplies double-precision vector x by double-precision scalar alpha and adds the result to double-precision vector y; that is, it overwrites double-precision y with double-precision alpha * x + y.
static void	JCublas.cublasDcopy(int n, Pointer x, int incx, Pointer y, int incy) void cublasDcopy (int n, const double *x, int incx, double *y, int incy) copies the double-precision vector x to the double-precision vector y.
static double	JCublas.cublasDdot(int n, Pointer x, int incx, Pointer y, int incy) double cublasDdot (int n, const double *x, int incx, const double *y, int incy) computes the dot product of two double-precision vectors.
static void	JCublas.cublasDgbmv(char trans, int m, int n, int kl, int ku, double alpha, Pointer A, int lda, Pointer x, int incx, double beta, Pointer y, int incy) void cublasDgbmv (char trans, int m, int n, int kl, int ku, double alpha, const double *A, int lda, const double *x, int incx, double beta, double *y, int incy); performs one of the matrix-vector operations y = alpha*op(A)*x + beta*y, op(A)=A or op(A) = transpose(A) alpha and beta are double precision scalars.
static void	JCublas.cublasDgemm(char transa, char transb, int m, int n, int k, double alpha, Pointer A, int lda, Pointer B, int ldb, double beta, Pointer C, int ldc) void cublasDgemm (char transa, char transb, int m, int n, int k, double alpha, const double *A, int lda, const double *B, int ldb, double beta, double *C, int ldc) computes the product of matrix A and matrix B, multiplies the result by scalar alpha, and adds the sum to the product of matrix C and scalar beta.
static void	JCublas.cublasDgemv(char trans, int m, int n, double alpha, Pointer A, int lda, Pointer x, int incx, double beta, Pointer y, int incy) cublasDgemv (char trans, int m, int n, double alpha, const double *A, int lda, const double *x, int incx, double beta, double *y, int incy) performs one of the matrix-vector operations y = alpha * op(A) * x + beta * y, where op(A) is one of op(A) = A or op(A) = transpose(A) where alpha and beta are double precision scalars, x and y are double precision vectors, and A is an m x n matrix consisting of double precision elements.
static void	JCublas.cublasDger(int m, int n, double alpha, Pointer x, int incx, Pointer y, int incy, Pointer A, int lda) cublasDger (int m, int n, double alpha, const double *x, int incx, const double *y, int incy, double *A, int lda) performs the symmetric rank 1 operation A = alpha * x * transpose(y) + A, where alpha is a double precision scalar, x is an m element double precision vector, y is an n element double precision vector, and A is an m by n matrix consisting of double precision elements.
static double	JCublas.cublasDnrm2(int n, Pointer x, int incx) double dnrm2 (int n, const double *x, int incx) computes the Euclidean norm of the double-precision n-vector x (with storage increment incx).
static void	JCublas.cublasDrot(int n, Pointer x, int incx, Pointer y, int incy, double sc, double ss) void cublasDrot (int n, double *x, int incx, double *y, int incy, double sc, double ss) multiplies a 2x2 matrix ( sc ss) with the 2xn matrix ( transpose(x) ) (-ss sc) ( transpose(y) ) The elements of x are in x[lx + i * incx], i = 0 ...
static void	JCublas.cublasDrotg(Pointer host_sa, Pointer host_sb, Pointer host_sc, Pointer host_ss) void cublasDrotg (double *host_sa, double *host_sb, double *host_sc, double *host_ss) constructs the Givens tranformation ( sc ss ) G = ( ) , sc^2 + ss^2 = 1, (-ss sc ) which zeros the second entry of the 2-vector transpose(sa, sb).
static void	JCublas.cublasDrotm(int n, Pointer x, int incx, Pointer y, int incy, double[] sparam) Wrapper for CUBLAS function.
static void	JCublas.cublasDsbmv(char uplo, int n, int k, double alpha, Pointer A, int lda, Pointer x, int incx, double beta, Pointer y, int incy) void cublasDsbmv (char uplo, int n, int k, double alpha, const double *A, int lda, const double *x, int incx, double beta, double *y, int incy) performs the matrix-vector operation y := alpha*A*x + beta*y alpha and beta are double precision scalars.
static void	JCublas.cublasDscal(int n, double alpha, Pointer x, int incx) void cublasDscal (int n, double alpha, double *x, int incx) replaces double-precision vector x with double-precision alpha * x.
static void	JCublas.cublasDspmv(char uplo, int n, double alpha, Pointer AP, Pointer x, int incx, double beta, Pointer y, int incy) void cublasDspmv (char uplo, int n, double alpha, const double *AP, const double *x, int incx, double beta, double *y, int incy) performs the matrix-vector operation y = alpha * A * x + beta * y Alpha and beta are double precision scalars, and x and y are double precision vectors with n elements.
static void	JCublas.cublasDspr(char uplo, int n, double alpha, Pointer x, int incx, Pointer AP) void cublasDspr (char uplo, int n, double alpha, const double *x, int incx, double *AP) performs the symmetric rank 1 operation A = alpha * x * transpose(x) + A, where alpha is a double precision scalar and x is an n element double precision vector.
static void	JCublas.cublasDspr2(char uplo, int n, double alpha, Pointer x, int incx, Pointer y, int incy, Pointer AP) void cublasDspr2 (char uplo, int n, double alpha, const double *x, int incx, const double *y, int incy, double *AP) performs the symmetric rank 2 operation A = alpha*x*transpose(y) + alpha*y*transpose(x) + A, where alpha is a double precision scalar, and x and y are n element double precision vectors.
static void	JCublas.cublasDswap(int n, Pointer x, int incx, Pointer y, int incy) void cublasDswap (int n, double *x, int incx, double *y, int incy) replaces double-precision vector x with double-precision alpha * x.
static void	JCublas.cublasDsymm(char side, char uplo, int m, int n, double alpha, Pointer A, int lda, Pointer B, int ldb, double beta, Pointer C, int ldc) void cublasDsymm (char side, char uplo, int m, int n, double alpha, const double *A, int lda, const double *B, int ldb, double beta, double *C, int ldc); performs one of the matrix-matrix operations C = alpha * A * B + beta * C, or C = alpha * B * A + beta * C, where alpha and beta are double precision scalars, A is a symmetric matrix consisting of double precision elements and stored in either lower or upper storage mode, and B and C are m x n matrices consisting of double precision elements.
static void	JCublas.cublasDsymv(char uplo, int n, double alpha, Pointer A, int lda, Pointer x, int incx, double beta, Pointer y, int incy) void cublasDsymv (char uplo, int n, double alpha, const double *A, int lda, const double *x, int incx, double beta, double *y, int incy) performs the matrix-vector operation y = alpha*A*x + beta*y Alpha and beta are double precision scalars, and x and y are double precision vectors, each with n elements.
static void	JCublas.cublasDsyr(char uplo, int n, double alpha, Pointer x, int incx, Pointer A, int lda) void cublasDsyr (char uplo, int n, double alpha, const double *x, int incx, double *A, int lda) performs the symmetric rank 1 operation A = alpha * x * transpose(x) + A, where alpha is a double precision scalar, x is an n element double precision vector and A is an n x n symmetric matrix consisting of double precision elements.
static void	JCublas.cublasDsyr2(char uplo, int n, double alpha, Pointer x, int incx, Pointer y, int incy, Pointer A, int lda) void cublasDsyr2 (char uplo, int n, double alpha, const double *x, int incx, const double *y, int incy, double *A, int lda) performs the symmetric rank 2 operation A = alpha*x*transpose(y) + alpha*y*transpose(x) + A, where alpha is a double precision scalar, x and y are n element double precision vector and A is an n by n symmetric matrix consisting of double precision elements.
static void	JCublas.cublasDsyr2k(char uplo, char trans, int n, int k, double alpha, Pointer A, int lda, Pointer B, int ldb, double beta, Pointer C, int ldc) void cublasDsyr2k (char uplo, char trans, int n, int k, double alpha, const double *A, int lda, const double *B, int ldb, double beta, double *C, int ldc) performs one of the symmetric rank 2k operations C = alpha * A * transpose(B) + alpha * B * transpose(A) + beta * C, or C = alpha * transpose(A) * B + alpha * transpose(B) * A + beta * C.
static void	JCublas.cublasDsyrk(char uplo, char trans, int n, int k, double alpha, Pointer A, int lda, double beta, Pointer C, int ldc) void cublasDsyrk (char uplo, char trans, int n, int k, double alpha, const double *A, int lda, double beta, double *C, int ldc) performs one of the symmetric rank k operations C = alpha * A * transpose(A) + beta * C, or C = alpha * transpose(A) * A + beta * C.
static void	JCublas.cublasDtbmv(char uplo, char trans, char diag, int n, int k, Pointer A, int lda, Pointer x, int incx) void cublasDtbmv (char uplo, char trans, char diag, int n, int k, const double *A, int lda, double *x, int incx) performs one of the matrix-vector operations x = op(A) * x, where op(A) = A, or op(A) = transpose(A).
static void	JCublas.cublasDtbsv(char uplo, char trans, char diag, int n, int k, Pointer A, int lda, Pointer x, int incx) void cublasDtbsv (char uplo, char trans, char diag, int n, int k, const double *A, int lda, double *X, int incx) solves one of the systems of equations op(A)*x = b, where op(A) is either op(A) = A or op(A) = transpose(A).
static void	JCublas.cublasDtpmv(char uplo, char trans, char diag, int n, Pointer AP, Pointer x, int incx) void cublasDtpmv (char uplo, char trans, char diag, int n, const double *AP, double *x, int incx); performs one of the matrix-vector operations x = op(A) * x, where op(A) = A, or op(A) = transpose(A).
static void	JCublas.cublasDtpsv(char uplo, char trans, char diag, int n, Pointer AP, Pointer x, int incx) void cublasDtpsv (char uplo, char trans, char diag, int n, const double *AP, double *X, int incx) solves one of the systems of equations op(A)*x = b, where op(A) is either op(A) = A or op(A) = transpose(A).
static void	JCublas.cublasDtrmm(char side, char uplo, char transa, char diag, int m, int n, double alpha, Pointer A, int lda, Pointer B, int ldb) void cublasDtrmm (char side, char uplo, char transa, char diag, int m, int n, double alpha, const double *A, int lda, const double *B, int ldb) performs one of the matrix-matrix operations B = alpha * op(A) * B, or B = alpha * B * op(A) where alpha is a double-precision scalar, B is an m x n matrix composed of double precision elements, and A is a unit or non-unit, upper or lower, triangular matrix composed of double precision elements.
static void	JCublas.cublasDtrmv(char uplo, char trans, char diag, int n, Pointer A, int lda, Pointer x, int incx) void cublasDtrmv (char uplo, char trans, char diag, int n, const double *A, int lda, double *x, int incx); performs one of the matrix-vector operations x = op(A) * x, where op(A) = = A, or op(A) = transpose(A).
static void	JCublas.cublasDtrsm(char side, char uplo, char transa, char diag, int m, int n, double alpha, Pointer A, int lda, Pointer B, int ldb) void cublasDtrsm (char side, char uplo, char transa, char diag, int m, int n, double alpha, const double *A, int lda, double *B, int ldb) solves one of the matrix equations op(A) * X = alpha * B, or X * op(A) = alpha * B, where alpha is a double precision scalar, and X and B are m x n matrices that are composed of double precision elements.
static void	JCublas.cublasDtrsv(char uplo, char trans, char diag, int n, Pointer A, int lda, Pointer x, int incx) void cublasDtrsv (char uplo, char trans, char diag, int n, const double *A, int lda, double *x, int incx) solves a system of equations op(A) * x = b, where op(A) is either A or transpose(A).
static double	JCublas.cublasDzasum(int n, Pointer x, int incx) double cublasDzasum (int n, const cuDoubleComplex *x, int incx) takes the sum of the absolute values of a complex vector and returns a double precision result.
static double	JCublas.cublasDznrm2(int n, Pointer x, int incx) double cublasDznrm2 (int n, const cuDoubleComplex *x, int incx) computes the Euclidean norm of the double precision complex n-vector x.
static int	JCublas.cublasFree(Pointer ptr) Wrapper for CUBLAS function. cublasStatus cublasFree (const void *devicePtr) destroys the object in GPU memory space pointed to by devicePtr. Return Values ------------- CUBLAS_STATUS_NOT_INITIALIZED if CUBLAS library has not been initialized CUBLAS_STATUS_INTERNAL_ERROR if the object could not be deallocated CUBLAS_STATUS_SUCCESS if object was destroyed successfully
static int	JCublas.cublasGetMatrix(int rows, int cols, int elemSize, Pointer A, int lda, Pointer B, int ldb) Wrapper for CUBLAS function. cublasStatus 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	JCublas.cublasGetMatrix(int rows, int cols, Pointer A, int lda, cuComplex[] B, int offsetB, int ldb) Extended wrapper for arrays of cuComplex values.
static int	JCublas.cublasGetMatrix(int rows, int cols, Pointer A, int lda, cuDoubleComplex[] B, int offsetB, int ldb) Extended wrapper for arrays of cuDoubleComplex values.
static int	JCublas.cublasGetVector(int n, int elemSize, Pointer x, int incx, Pointer y, int incy) Wrapper for CUBLAS function. cublasStatus 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	JCublas.cublasGetVector(int n, Pointer x, int incx, cuComplex[] y, int offsety, int incy) Extended wrapper for arrays of cuComplex values.
static int	JCublas.cublasGetVector(int n, Pointer x, int incx, cuDoubleComplex[] y, int offsety, int incy) Extended wrapper for arrays of cuDoubleComplex values.
static int	JCublas.cublasIcamax(int n, Pointer x, int incx) int cublasIcamax (int n, const float *x, int incx) finds the smallest index of the element having maximum absolute value in single-complex vector x; that is, the result is the first i, i = 0 to n - 1 that maximizes abs(real(x[1+i*incx]))+abs(imag(x[1 + i * incx])).
static int	JCublas.cublasIcamin(int n, Pointer x, int incx) int cublasIcamin (int n, const float *x, int incx) finds the smallest index of the element having minimum absolute value in single-complex vector x; that is, the result is the first i, i = 0 to n - 1 that minimizes abs(real(x[1+i*incx]))+abs(imag(x[1 + i * incx])).
static int	JCublas.cublasIdamax(int n, Pointer x, int incx) int idamax (int n, const double *x, int incx) finds the smallest index of the maximum magnitude element of double- precision vector x; that is, the result is the first i, i = 0 to n - 1, that maximizes abs(x[1 + i * incx])).
static int	JCublas.cublasIdamin(int n, Pointer x, int incx) int idamin (int n, const double *x, int incx) finds the smallest index of the minimum magnitude element of double- precision vector x; that is, the result is the first i, i = 0 to n - 1, that minimizes abs(x[1 + i * incx])).
static int	JCublas.cublasIsamax(int n, Pointer x, int incx) int cublasIsamax (int n, const float *x, int incx) finds the smallest index of the maximum magnitude element of single precision vector x; that is, the result is the first i, i = 0 to n - 1, that maximizes abs(x[1 + i * incx])).
static int	JCublas.cublasIsamin(int n, Pointer x, int incx) int cublasIsamin (int n, const float *x, int incx) finds the smallest index of the minimum magnitude element of single precision vector x; that is, the result is the first i, i = 0 to n - 1, that minimizes abs(x[1 + i * incx])).
static int	JCublas.cublasIzamax(int n, Pointer x, int incx) int cublasIzamax (int n, const double *x, int incx) finds the smallest index of the element having maximum absolute value in double-complex vector x; that is, the result is the first i, i = 0 to n - 1 that maximizes abs(real(x[1+i*incx]))+abs(imag(x[1 + i * incx])).
static int	JCublas.cublasIzamin(int n, Pointer x, int incx) int cublasIzamin (int n, const cuDoubleComplex *x, int incx) finds the smallest index of the element having minimum absolute value in double-complex vector x; that is, the result is the first i, i = 0 to n - 1 that minimizes abs(real(x[1+i*incx]))+abs(imag(x[1 + i * incx])).
static float	JCublas.cublasSasum(int n, Pointer x, int incx) float cublasSasum (int n, const float *x, int incx) computes the sum of the absolute values of the elements of single precision vector x; that is, the result is the sum from i = 0 to n - 1 of abs(x[1 + i * incx]).
static void	JCublas.cublasSaxpy(int n, float alpha, Pointer x, int incx, Pointer y, int incy) void cublasSaxpy (int n, float alpha, const float *x, int incx, float *y, int incy) multiplies single precision vector x by single precision scalar alpha and adds the result to single precision vector y; that is, it overwrites single precision y with single precision alpha * x + y.
static float	JCublas.cublasScasum(int n, Pointer x, int incx) float cublasScasum (int n, const cuDouble *x, int incx) takes the sum of the absolute values of a complex vector and returns a single precision result.
static float	JCublas.cublasScnrm2(int n, Pointer x, int incx) float cublasScnrm2 (int n, const cuComplex *x, int incx) computes the Euclidean norm of the single-complex n-vector x.
static void	JCublas.cublasScopy(int n, Pointer x, int incx, Pointer y, int incy) void cublasScopy (int n, const float *x, int incx, float *y, int incy) copies the single precision vector x to the single precision vector y.
static float	JCublas.cublasSdot(int n, Pointer x, int incx, Pointer y, int incy) float cublasSdot (int n, const float *x, int incx, const float *y, int incy) computes the dot product of two single precision vectors.
static int	JCublas.cublasSetMatrix(int rows, int cols, cuComplex[] A, int offsetA, int lda, Pointer B, int ldb) Extended wrapper for arrays of cuComplex values.
static int	JCublas.cublasSetMatrix(int rows, int cols, cuDoubleComplex[] A, int offsetA, int lda, Pointer B, int ldb) Extended wrapper for arrays of cuDoubleComplex values.
static int	JCublas.cublasSetMatrix(int rows, int cols, int elemSize, Pointer A, int lda, Pointer B, int ldb) Wrapper for CUBLAS function. cublasStatus 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	JCublas.cublasSetVector(int n, cuComplex[] x, int offsetx, int incx, Pointer y, int incy) Extended wrapper for arrays of cuComplex values.
static int	JCublas.cublasSetVector(int n, cuDoubleComplex[] x, int offsetx, int incx, Pointer y, int incy) Extended wrapper for arrays of cuDoubleComplex values.
static int	JCublas.cublasSetVector(int n, int elemSize, Pointer x, int incx, Pointer y, int incy) Wrapper for CUBLAS function. cublasStatus 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 void	JCublas.cublasSgbmv(char trans, int m, int n, int kl, int ku, float alpha, Pointer A, int lda, Pointer x, int incx, float beta, Pointer y, int incy) void cublasSgbmv (char trans, int m, int n, int kl, int ku, float alpha, const float *A, int lda, const float *x, int incx, float beta, float *y, int incy) performs one of the matrix-vector operations y = alpha*op(A)*x + beta*y, op(A)=A or op(A) = transpose(A) alpha and beta are single precision scalars.
static void	JCublas.cublasSgemm(char transa, char transb, int m, int n, int k, float alpha, Pointer A, int lda, Pointer B, int ldb, float beta, Pointer C, int ldc) void cublasSgemm (char transa, char transb, int m, int n, int k, float alpha, const float *A, int lda, const float *B, int ldb, float beta, float *C, int ldc) computes the product of matrix A and matrix B, multiplies the result by a scalar alpha, and adds the sum to the product of matrix C and scalar beta.
static void	JCublas.cublasSgemv(char trans, int m, int n, float alpha, Pointer A, int lda, Pointer x, int incx, float beta, Pointer y, int incy) cublasSgemv (char trans, int m, int n, float alpha, const float *A, int lda, const float *x, int incx, float beta, float *y, int incy) performs one of the matrix-vector operations y = alpha * op(A) * x + beta * y, where op(A) is one of op(A) = A or op(A) = transpose(A) where alpha and beta are single precision scalars, x and y are single precision vectors, and A is an m x n matrix consisting of single precision elements.
static void	JCublas.cublasSger(int m, int n, float alpha, Pointer x, int incx, Pointer y, int incy, Pointer A, int lda) cublasSger (int m, int n, float alpha, const float *x, int incx, const float *y, int incy, float *A, int lda) performs the symmetric rank 1 operation A = alpha * x * transpose(y) + A, where alpha is a single precision scalar, x is an m element single precision vector, y is an n element single precision vector, and A is an m by n matrix consisting of single precision elements.
static float	JCublas.cublasSnrm2(int n, Pointer x, int incx) float cublasSnrm2 (int n, const float *x, int incx) computes the Euclidean norm of the single precision n-vector x (with storage increment incx).
static void	JCublas.cublasSrot(int n, Pointer x, int incx, Pointer y, int incy, float sc, float ss) void cublasSrot (int n, float *x, int incx, float *y, int incy, float sc, float ss) multiplies a 2x2 matrix ( sc ss) with the 2xn matrix ( transpose(x) ) (-ss sc) ( transpose(y) ) The elements of x are in x[lx + i * incx], i = 0 ...
static void	JCublas.cublasSrotg(Pointer host_sa, Pointer host_sb, Pointer host_sc, Pointer host_ss) void cublasSrotg (float *host_sa, float *host_sb, float *host_sc, float *host_ss) constructs the Givens tranformation ( sc ss ) G = ( ) , sc^2 + ss^2 = 1, (-ss sc ) which zeros the second entry of the 2-vector transpose(sa, sb).
static void	JCublas.cublasSrotm(int n, Pointer x, int incx, Pointer y, int incy, float[] sparam) Wrapper for CUBLAS function.
static void	JCublas.cublasSsbmv(char uplo, int n, int k, float alpha, Pointer A, int lda, Pointer x, int incx, float beta, Pointer y, int incy) void cublasSsbmv (char uplo, int n, int k, float alpha, const float *A, int lda, const float *x, int incx, float beta, float *y, int incy) performs the matrix-vector operation y := alpha*A*x + beta*y alpha and beta are single precision scalars.
static void	JCublas.cublasSscal(int n, float alpha, Pointer x, int incx) void sscal (int n, float alpha, float *x, int incx) replaces single precision vector x with single precision alpha * x.
static void	JCublas.cublasSspmv(char uplo, int n, float alpha, Pointer AP, Pointer x, int incx, float beta, Pointer y, int incy) void cublasSspmv (char uplo, int n, float alpha, const float *AP, const float *x, int incx, float beta, float *y, int incy) performs the matrix-vector operation y = alpha * A * x + beta * y Alpha and beta are single precision scalars, and x and y are single precision vectors with n elements.
static void	JCublas.cublasSspr(char uplo, int n, float alpha, Pointer x, int incx, Pointer AP) void cublasSspr (char uplo, int n, float alpha, const float *x, int incx, float *AP) performs the symmetric rank 1 operation A = alpha * x * transpose(x) + A, where alpha is a single precision scalar and x is an n element single precision vector.
static void	JCublas.cublasSspr2(char uplo, int n, float alpha, Pointer x, int incx, Pointer y, int incy, Pointer AP) void cublasSspr2 (char uplo, int n, float alpha, const float *x, int incx, const float *y, int incy, float *AP) performs the symmetric rank 2 operation A = alpha*x*transpose(y) + alpha*y*transpose(x) + A, where alpha is a single precision scalar, and x and y are n element single precision vectors.
static void	JCublas.cublasSswap(int n, Pointer x, int incx, Pointer y, int incy) void cublasSswap (int n, float *x, int incx, float *y, int incy) replaces single precision vector x with single precision alpha * x.
static void	JCublas.cublasSsymm(char side, char uplo, int m, int n, float alpha, Pointer A, int lda, Pointer B, int ldb, float beta, Pointer C, int ldc) void cublasSsymm (char side, char uplo, int m, int n, float alpha, const float *A, int lda, const float *B, int ldb, float beta, float *C, int ldc); performs one of the matrix-matrix operations C = alpha * A * B + beta * C, or C = alpha * B * A + beta * C, where alpha and beta are single precision scalars, A is a symmetric matrix consisting of single precision elements and stored in either lower or upper storage mode, and B and C are m x n matrices consisting of single precision elements.
static void	JCublas.cublasSsymv(char uplo, int n, float alpha, Pointer A, int lda, Pointer x, int incx, float beta, Pointer y, int incy) void cublasSsymv (char uplo, int n, float alpha, const float *A, int lda, const float *x, int incx, float beta, float *y, int incy) performs the matrix-vector operation y = alpha*A*x + beta*y Alpha and beta are single precision scalars, and x and y are single precision vectors, each with n elements.
static void	JCublas.cublasSsyr(char uplo, int n, float alpha, Pointer x, int incx, Pointer A, int lda) void cublasSsyr (char uplo, int n, float alpha, const float *x, int incx, float *A, int lda) performs the symmetric rank 1 operation A = alpha * x * transpose(x) + A, where alpha is a single precision scalar, x is an n element single precision vector and A is an n x n symmetric matrix consisting of single precision elements.
static void	JCublas.cublasSsyr2(char uplo, int n, float alpha, Pointer x, int incx, Pointer y, int incy, Pointer A, int lda) void cublasSsyr2 (char uplo, int n, float alpha, const float *x, int incx, const float *y, int incy, float *A, int lda) performs the symmetric rank 2 operation A = alpha*x*transpose(y) + alpha*y*transpose(x) + A, where alpha is a single precision scalar, x and y are n element single precision vector and A is an n by n symmetric matrix consisting of single precision elements.
static void	JCublas.cublasSsyr2k(char uplo, char trans, int n, int k, float alpha, Pointer A, int lda, Pointer B, int ldb, float beta, Pointer C, int ldc) void cublasSsyr2k (char uplo, char trans, int n, int k, float alpha, const float *A, int lda, const float *B, int ldb, float beta, float *C, int ldc) performs one of the symmetric rank 2k operations C = alpha * A * transpose(B) + alpha * B * transpose(A) + beta * C, or C = alpha * transpose(A) * B + alpha * transpose(B) * A + beta * C.
static void	JCublas.cublasSsyrk(char uplo, char trans, int n, int k, float alpha, Pointer A, int lda, float beta, Pointer C, int ldc) void cublasSsyrk (char uplo, char trans, int n, int k, float alpha, const float *A, int lda, float beta, float *C, int ldc) performs one of the symmetric rank k operations C = alpha * A * transpose(A) + beta * C, or C = alpha * transpose(A) * A + beta * C.
static void	JCublas.cublasStbmv(char uplo, char trans, char diag, int n, int k, Pointer A, int lda, Pointer x, int incx) void cublasStbmv (char uplo, char trans, char diag, int n, int k, const float *A, int lda, float *x, int incx) performs one of the matrix-vector operations x = op(A) * x, where op(A) = A or op(A) = transpose(A).
static void	JCublas.cublasStbsv(char uplo, char trans, char diag, int n, int k, Pointer A, int lda, Pointer x, int incx) void cublasStbsv (char uplo, char trans, char diag, int n, int k, const float *A, int lda, float *X, int incx) solves one of the systems of equations op(A)*x = b, where op(A) is either op(A) = A or op(A) = transpose(A).
static void	JCublas.cublasStpmv(char uplo, char trans, char diag, int n, Pointer AP, Pointer x, int incx) void cublasStpmv (char uplo, char trans, char diag, int n, const float *AP, float *x, int incx); performs one of the matrix-vector operations x = op(A) * x, where op(A) = A, or op(A) = transpose(A).
static void	JCublas.cublasStpsv(char uplo, char trans, char diag, int n, Pointer AP, Pointer x, int incx) void cublasStpsv (char uplo, char trans, char diag, int n, const float *AP, float *X, int incx) solves one of the systems of equations op(A)*x = b, where op(A) is either op(A) = A or op(A) = transpose(A).
static void	JCublas.cublasStrmm(char side, char uplo, char transa, char diag, int m, int n, float alpha, Pointer A, int lda, Pointer B, int ldb) void cublasStrmm (char side, char uplo, char transa, char diag, int m, int n, float alpha, const float *A, int lda, const float *B, int ldb) performs one of the matrix-matrix operations B = alpha * op(A) * B, or B = alpha * B * op(A) where alpha is a single-precision scalar, B is an m x n matrix composed of single precision elements, and A is a unit or non-unit, upper or lower, triangular matrix composed of single precision elements.
static void	JCublas.cublasStrmv(char uplo, char trans, char diag, int n, Pointer A, int lda, Pointer x, int incx) void cublasStrmv (char uplo, char trans, char diag, int n, const float *A, int lda, float *x, int incx); performs one of the matrix-vector operations x = op(A) * x, where op(A) = = A, or op(A) = transpose(A).
static void	JCublas.cublasStrsm(char side, char uplo, char transa, char diag, int m, int n, float alpha, Pointer A, int lda, Pointer B, int ldb) void cublasStrsm (char side, char uplo, char transa, char diag, int m, int n, float alpha, const float *A, int lda, float *B, int ldb) solves one of the matrix equations op(A) * X = alpha * B, or X * op(A) = alpha * B, where alpha is a single precision scalar, and X and B are m x n matrices that are composed of single precision elements.
static void	JCublas.cublasStrsv(char uplo, char trans, char diag, int n, Pointer A, int lda, Pointer x, int incx) void cublasStrsv (char uplo, char trans, char diag, int n, const float *A, int lda, float *x, int incx) solves a system of equations op(A) * x = b, where op(A) is either A or transpose(A).
static void	JCublas.cublasZaxpy(int n, cuDoubleComplex alpha, Pointer x, int incx, Pointer y, int incy) void cublasZaxpy (int n, cuDoubleComplex alpha, const cuDoubleComplex *x, int incx, cuDoubleComplex *y, int incy) multiplies double-complex vector x by double-complex scalar alpha and adds the result to double-complex vector y; that is, it overwrites double-complex y with double-complex alpha * x + y.
static void	JCublas.cublasZcopy(int n, Pointer x, int incx, Pointer y, int incy) void cublasZcopy (int n, const cuDoubleComplex *x, int incx, cuDoubleComplex *y, int incy) copies the double-complex vector x to the double-complex vector y.
static void	JCublas.cublasZdrot(int n, Pointer x, int incx, Pointer y, int incy, double c, double s) void zdrot (int n, cuDoubleComplex *x, int incx, cuCumplex *y, int incy, double c, double s) multiplies a 2x2 matrix ( c s) with the 2xn matrix ( transpose(x) ) (-s c) ( transpose(y) ) The elements of x are in x[lx + i * incx], i = 0 ...
static void	JCublas.cublasZdscal(int n, double alpha, Pointer x, int incx) void cublasZdscal (int n, double alpha, cuDoubleComplex *x, int incx) replaces double-complex vector x with double-complex alpha * x.
static void	JCublas.cublasZgbmv(char trans, int m, int n, int kl, int ku, cuDoubleComplex alpha, Pointer A, int lda, Pointer x, int incx, cuDoubleComplex beta, Pointer y, int incy) void cublasZgbmv (char trans, int m, int n, int kl, int ku, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, cuDoubleComplex beta, cuDoubleComplex *y, int incy); performs one of the matrix-vector operations y = alpha*op(A)*x + beta*y, op(A)=A or op(A) = transpose(A) alpha and beta are double precision complex scalars.
static void	JCublas.cublasZgemm(char transa, char transb, int m, int n, int k, cuDoubleComplex alpha, Pointer A, int lda, Pointer B, int ldb, cuDoubleComplex beta, Pointer C, int ldc) void cublasZgemm (char transa, char transb, int m, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, cuDoubleComplex beta, cuDoubleComplex *C, int ldc) zgemm performs one of the matrix-matrix operations C = alpha * op(A) * op(B) + beta*C, where op(X) is one of op(X) = X or op(X) = transpose or op(X) = conjg(transpose(X)) alpha and beta are double-complex scalars, and A, B and C are matrices consisting of double-complex elements, with op(A) an m x k matrix, op(B) a k x n matrix and C an m x n matrix.
static void	JCublas.cublasZgemv(char trans, int m, int n, cuDoubleComplex alpha, Pointer A, int lda, Pointer x, int incx, cuDoubleComplex beta, Pointer y, int incy) cublasZgemv (char trans, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, cuDoubleComplex beta, cuDoubleComplex *y, int incy) performs one of the matrix-vector operations y = alpha * op(A) * x + beta * y, where op(A) is one of op(A) = A or op(A) = transpose(A) where alpha and beta are double precision scalars, x and y are double precision vectors, and A is an m x n matrix consisting of double precision elements.
static void	JCublas.cublasZgerc(int m, int n, cuDoubleComplex alpha, Pointer x, int incx, Pointer y, int incy, Pointer A, int lda) cublasZgerc (int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, int incy, cuDoubleComplex *A, int lda) performs the symmetric rank 1 operation A = alpha * x * conjugate(transpose(y)) + A, where alpha is a double precision complex scalar, x is an m element double precision complex vector, y is an n element double precision complex vector, and A is an m by n matrix consisting of double precision complex elements.
static void	JCublas.cublasZgeru(int m, int n, cuDoubleComplex alpha, Pointer x, int incx, Pointer y, int incy, Pointer A, int lda) cublasZgeru (int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, int incy, cuDoubleComplex *A, int lda) performs the symmetric rank 1 operation A = alpha * x * transpose(y) + A, where alpha is a double precision complex scalar, x is an m element double precision complex vector, y is an n element double precision complex vector, and A is an m by n matrix consisting of double precision complex elements.
static void	JCublas.cublasZhbmv(char uplo, int n, int k, cuDoubleComplex alpha, Pointer A, int lda, Pointer x, int incx, cuDoubleComplex beta, Pointer y, int incy) void cublasZhbmv (char uplo, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, cuDoubleComplex beta, cuDoubleComplex *y, int incy) performs the matrix-vector operation y := alpha*A*x + beta*y alpha and beta are double precision complex scalars.
static void	JCublas.cublasZhemm(char side, char uplo, int m, int n, cuDoubleComplex alpha, Pointer A, int lda, Pointer B, int ldb, cuDoubleComplex beta, Pointer C, int ldc) void cublasZhemm (char side, char uplo, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, cuDoubleComplex beta, cuDoubleComplex *C, int ldc); performs one of the matrix-matrix operations C = alpha * A * B + beta * C, or C = alpha * B * A + beta * C, where alpha and beta are double precision complex scalars, A is a hermitian matrix consisting of double precision complex elements and stored in either lower or upper storage mode, and B and C are m x n matrices consisting of double precision complex elements.
static void	JCublas.cublasZhemv(char uplo, int n, cuDoubleComplex alpha, Pointer A, int lda, Pointer x, int incx, cuDoubleComplex beta, Pointer y, int incy) void cublasZhemv (char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, cuDoubleComplex beta, cuDoubleComplex *y, int incy) performs the matrix-vector operation y = alpha*A*x + beta*y Alpha and beta are double precision complex scalars, and x and y are double precision complex vectors, each with n elements.
static void	JCublas.cublasZher(char uplo, int n, double alpha, Pointer x, int incx, Pointer A, int lda) void cublasZher (char uplo, int n, double alpha, const cuDoubleComplex *x, int incx, cuDoubleComplex *A, int lda) performs the hermitian rank 1 operation A = alpha * x * conjugate(transpose(x)) + A, where alpha is a double precision real scalar, x is an n element double precision complex vector and A is an n x n hermitian matrix consisting of double precision complex elements.
static void	JCublas.cublasZher2(char uplo, int n, cuDoubleComplex alpha, Pointer x, int incx, Pointer y, int incy, Pointer A, int lda) void cublasZher2 (char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, int incy, cuDoubleComplex *A, int lda) performs the hermitian rank 2 operation A = alpha*x*conjugate(transpose(y)) + conjugate(alpha)*y*conjugate(transpose(x)) + A, where alpha is a double precision complex scalar, x and y are n element double precision complex vector and A is an n by n hermitian matrix consisting of double precision complex elements.
static void	JCublas.cublasZher2k(char uplo, char trans, int n, int k, cuDoubleComplex alpha, Pointer A, int lda, Pointer B, int ldb, double beta, Pointer C, int ldc) void cublasZher2k (char uplo, char trans, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, double beta, cuDoubleComplex *C, int ldc) performs one of the hermitian rank 2k operations C = alpha * A * conjugate(transpose(B)) + conjugate(alpha) * B * conjugate(transpose(A)) + beta * C , or C = alpha * conjugate(transpose(A)) * B + conjugate(alpha) * conjugate(transpose(B)) * A + beta * C.
static void	JCublas.cublasZherk(char uplo, char trans, int n, int k, double alpha, Pointer A, int lda, double beta, Pointer C, int ldc) void cublasZherk (char uplo, char trans, int n, int k, double alpha, const cuDoubleComplex *A, int lda, double beta, cuDoubleComplex *C, int ldc) performs one of the hermitian rank k operations C = alpha * A * conjugate(transpose(A)) + beta * C, or C = alpha * conjugate(transpose(A)) * A + beta * C.
static void	JCublas.cublasZhpmv(char uplo, int n, cuDoubleComplex alpha, Pointer AP, Pointer x, int incx, cuDoubleComplex beta, Pointer y, int incy) void cublasZhpmv (char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex *AP, const cuDoubleComplex *x, int incx, cuDoubleComplex beta, cuDoubleComplex *y, int incy) performs the matrix-vector operation y = alpha * A * x + beta * y Alpha and beta are double precision complex scalars, and x and y are double precision complex vectors with n elements.
static void	JCublas.cublasZhpr(char uplo, int n, double alpha, Pointer x, int incx, Pointer AP) void cublasZhpr (char uplo, int n, double alpha, const cuDoubleComplex *x, int incx, cuDoubleComplex *AP) performs the hermitian rank 1 operation A = alpha * x * conjugate(transpose(x)) + A, where alpha is a double precision real scalar and x is an n element double precision complex vector.
static void	JCublas.cublasZhpr2(char uplo, int n, cuDoubleComplex alpha, Pointer x, int incx, Pointer y, int incy, Pointer AP) void cublasZhpr2 (char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, int incy, cuDoubleComplex *AP) performs the hermitian rank 2 operation A = alpha*x*conjugate(transpose(y)) + conjugate(alpha)*y*conjugate(transpose(x)) + A, where alpha is a double precision complex scalar, and x and y are n element double precision complex vectors.
static void	JCublas.cublasZrot(int n, Pointer x, int incx, Pointer y, int incy, double sc, cuDoubleComplex cs) cublasZrot (int n, cuDoubleComplex *x, int incx, cuDoubleComplex *y, int incy, double sc, cuDoubleComplex cs) multiplies a 2x2 matrix ( sc cs) with the 2xn matrix ( transpose(x) ) (-conj(cs) sc) ( transpose(y) ) The elements of x are in x[lx + i * incx], i = 0 ...
static void	JCublas.cublasZrotg(Pointer host_ca, cuDoubleComplex cb, Pointer host_sc, Pointer host_cs) void cublasZrotg (cuDoubleComplex *host_ca, cuDoubleComplex cb, double *host_sc, double *host_cs) constructs the complex Givens tranformation ( sc cs ) G = ( ) , sc^2 + cabs(cs)^2 = 1, (-cs sc ) which zeros the second entry of the complex 2-vector transpose(ca, cb).
static void	JCublas.cublasZscal(int n, cuDoubleComplex alpha, Pointer x, int incx) void cublasZscal (int n, cuComplex alpha, cuComplex *x, int incx) replaces double-complex vector x with double-complex alpha * x.
static void	JCublas.cublasZswap(int n, Pointer x, int incx, Pointer y, int incy) void cublasZswap (int n, const cuDoubleComplex *x, int incx, cuDoubleComplex *y, int incy) interchanges the double-complex vector x with the double-complex vector y.
static void	JCublas.cublasZsymm(char side, char uplo, int m, int n, cuDoubleComplex alpha, Pointer A, int lda, Pointer B, int ldb, cuDoubleComplex beta, Pointer C, int ldc) void cublasZsymm (char side, char uplo, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, cuDoubleComplex beta, cuDoubleComplex *C, int ldc); performs one of the matrix-matrix operations C = alpha * A * B + beta * C, or C = alpha * B * A + beta * C, where alpha and beta are double precision complex scalars, A is a symmetric matrix consisting of double precision complex elements and stored in either lower or upper storage mode, and B and C are m x n matrices consisting of double precision complex elements.
static void	JCublas.cublasZsyr2k(char uplo, char trans, int n, int k, cuDoubleComplex alpha, Pointer A, int lda, Pointer B, int ldb, cuDoubleComplex beta, Pointer C, int ldc) void cublasZsyr2k (char uplo, char trans, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, cuDoubleComplex beta, cuDoubleComplex *C, int ldc) performs one of the symmetric rank 2k operations C = alpha * A * transpose(B) + alpha * B * transpose(A) + beta * C, or C = alpha * transpose(A) * B + alpha * transpose(B) * A + beta * C.
static void	JCublas.cublasZsyrk(char uplo, char trans, int n, int k, cuDoubleComplex alpha, Pointer A, int lda, cuDoubleComplex beta, Pointer C, int ldc) void cublasZsyrk (char uplo, char trans, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, cuDoubleComplex beta, cuDoubleComplex *C, int ldc) performs one of the symmetric rank k operations C = alpha * A * transpose(A) + beta * C, or C = alpha * transpose(A) * A + beta * C.
static void	JCublas.cublasZtbmv(char uplo, char trans, char diag, int n, int k, Pointer A, int lda, Pointer x, int incx) void cublasZtbmv (char uplo, char trans, char diag, int n, int k, const cuDoubleComplex *A, int lda, cuDoubleComplex *x, int incx) performs one of the matrix-vector operations x = op(A) * x, where op(A) = A, op(A) = transpose(A) or op(A) = conjugate(transpose(A)).
static void	JCublas.cublasZtbsv(char uplo, char trans, char diag, int n, int k, Pointer A, int lda, Pointer x, int incx) void cublasZtbsv (char uplo, char trans, char diag, int n, int k, const cuDoubleComplex *A, int lda, cuDoubleComplex *X, int incx) solves one of the systems of equations op(A)*x = b, where op(A) is either op(A) = A , op(A) = transpose(A) or op(A) = conjugate(transpose(A)).
static void	JCublas.cublasZtpmv(char uplo, char trans, char diag, int n, Pointer AP, Pointer x, int incx) void cublasZtpmv (char uplo, char trans, char diag, int n, const cuDoubleComplex *AP, cuDoubleComplex *x, int incx); performs one of the matrix-vector operations x = op(A) * x, where op(A) = A, op(A) = transpose(A) or op(A) = conjugate(transpose(A)) .
static void	JCublas.cublasZtpsv(char uplo, char trans, char diag, int n, Pointer AP, Pointer x, int incx) void cublasZtpsv (char uplo, char trans, char diag, int n, const cuDoubleComplex *AP, cuDoubleComplex *X, int incx) solves one of the systems of equations op(A)*x = b, where op(A) is either op(A) = A , op(A) = transpose(A) or op(A) = conjugate(transpose)).
static void	JCublas.cublasZtrmm(char side, char uplo, char transa, char diag, int m, int n, cuDoubleComplex alpha, Pointer A, int lda, Pointer B, int ldb) void cublasZtrmm (char side, char uplo, char transa, char diag, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb) performs one of the matrix-matrix operations B = alpha * op(A) * B, or B = alpha * B * op(A) where alpha is a double-precision complex scalar, B is an m x n matrix composed of double precision complex elements, and A is a unit or non-unit, upper or lower, triangular matrix composed of double precision complex elements.
static void	JCublas.cublasZtrmv(char uplo, char trans, char diag, int n, Pointer A, int lda, Pointer x, int incx) void cublasZtrmv (char uplo, char trans, char diag, int n, const cuDoubleComplex *A, int lda, cuDoubleComplex *x, int incx); performs one of the matrix-vector operations x = op(A) * x, where op(A) = A, or op(A) = transpose(A) or op(A) = conjugate(transpose(A)).
static void	JCublas.cublasZtrsm(char side, char uplo, char transa, char diag, int m, int n, cuDoubleComplex alpha, Pointer A, int lda, Pointer B, int ldb) void cublasZtrsm (char side, char uplo, char transa, char diag, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, cuDoubleComplex *B, int ldb) solves one of the matrix equations op(A) * X = alpha * B, or X * op(A) = alpha * B, where alpha is a double precision complex scalar, and X and B are m x n matrices that are composed of double precision complex elements.
static void	JCublas.cublasZtrsv(char uplo, char trans, char diag, int n, Pointer A, int lda, Pointer x, int incx) void cublasZtrsv (char uplo, char trans, char diag, int n, const cuDoubleComplex *A, int lda, cuDoubleComplex *x, int incx) solves a system of equations op(A) * x = b, where op(A) is either A, transpose(A) or conjugate(transpose(A)).
static void	JCublas.printMatrix(int cols, Pointer A, int lda)
static void	JCublas.printVector(int n, Pointer x)

Uses of Pointer in jcuda.jcudpp

Methods in jcuda.jcudpp with parameters of type Pointer

static int	JCudpp.cudppCompact(CUDPPHandle planHandle, Pointer d_out, Pointer d_numValidElements, Pointer d_in, Pointer d_isValid, long numElements) Given an array d_in and an array of 1/0 flags in deviceValid, returns a compacted array in d_out of corresponding only the "valid" values from d_in. Takes as input an array of elements in GPU memory (d_in) and an equal-sized unsigned int array in GPU memory (deviceValid) that indicate which of those input elements are valid.
static int	JCudpp.cudppMultiScan(CUDPPHandle planHandle, Pointer d_out, Pointer d_in, long numElements, long numRows) Performs numRows parallel scan operations of numElements each on its input (d_in) and places the output in d_out, with the scan parameters set by config.
static int	JCudpp.cudppRand(CUDPPHandle planHandle, Pointer d_out, long numElements) Rand puts numElements random 32-bit elements into d_out. Outputs numElements random values to d_out.
static int	JCudpp.cudppScan(CUDPPHandle planHandle, Pointer d_out, Pointer d_in, long numElements) Performs a scan operation of numElements on its input in GPU memory (d_in) and places the output in GPU memory (d_out), with the scan parameters specified in the plan pointed to by planHandle. The input to a scan operation is an input array, a binary associative operator (like + or max), and an identity element for that operator (+'s identity is 0).
static int	JCudpp.cudppSegmentedScan(CUDPPHandle planHandle, Pointer d_out, Pointer d_idata, Pointer d_iflags, long numElements) Performs a segmented scan operation of numElements on its input in GPU memory (d_idata) and places the output in GPU memory (d_out), with the scan parameters specified in the plan pointed to by planHandle. The input to a segmented scan operation is an input array of data, an input array of flags which demarcate segments, a binary associative operator (like + or max), and an identity element for that operator (+'s identity is 0).
static int	JCudpp.cudppSort(CUDPPHandle planHandle, Pointer d_keys, Pointer d_values, int keyBits, long numElements) Sorts key-value pairs or keys only. Takes as input an array of keys in GPU memory (d_keys) and an optional array of corresponding values, and outputs sorted arrays of keys and (optionally) values in place.
static int	JCudpp.cudppSparseMatrix(CUDPPHandle sparseMatrixHandle, CUDPPConfiguration config, long numNonZeroElements, long numRows, Pointer A, Pointer h_rowIndices, Pointer h_indices) Create a CUDPP Sparse Matrix Object. The sparse matrix plan is a data structure containing state and intermediate storage space that CUDPP uses to perform sparse matrix dense vector multiply.
static int	JCudpp.cudppSparseMatrixVectorMultiply(CUDPPHandle sparseMatrixHandle, Pointer d_y, Pointer d_x) Perform matrix-vector multiply y = A*x for arbitrary sparse matrix A and vector x. Given a matrix object handle (which has been initialized using cudppSparseMatrix()), This function multiplies the input vector d_x by the matrix referred to by sparseMatrixHandle, returning the result in d_y. Parameters:

Uses of Pointer in jcuda.jcufft

Methods in jcuda.jcufft with parameters of type Pointer

static int	JCufft.cufftExecC2C(cufftHandle plan, Pointer cIdata, Pointer cOdata, int direction) Executes a CUFFT complex-to-complex transform plan.
static int	JCufft.cufftExecC2R(cufftHandle plan, Pointer cIdata, Pointer rOdata) Executes a CUFFT complex-to-real (implicitly inverse) transform plan.
static int	JCufft.cufftExecD2Z(cufftHandle plan, Pointer rIdata, Pointer cOdata) Executes a CUFFT real-to-complex (implicitly forward) transform plan for double precision values.
static int	JCufft.cufftExecR2C(cufftHandle plan, Pointer rIdata, Pointer cOdata) Executes a CUFFT real-to-complex (implicitly forward) transform plan.
static int	JCufft.cufftExecZ2D(cufftHandle plan, Pointer cIdata, Pointer rOdata) Executes a CUFFT complex-to-real (implicitly inverse) transform plan for double precision values.
static int	JCufft.cufftExecZ2Z(cufftHandle plan, Pointer cIdata, Pointer cOdata, int direction) Executes a CUFFT complex-to-complex transform plan for double precision values.

Uses of Pointer in jcuda.runtime

Fields in jcuda.runtime declared as Pointer

Pointer

cudaPitchedPtr.ptr Pointer to allocated memory.

Methods in jcuda.runtime with parameters of type Pointer

static int	JCuda.cudaBindTexture(long[] offset, textureReference texref, Pointer devPtr, cudaChannelFormatDesc desc, long size) Binds size bytes of the memory area pointed to by devPtr to texture reference texRef.
static int	JCuda.cudaBindTexture2D(long[] offset, textureReference texref, Pointer devPtr, cudaChannelFormatDesc desc, long width, long height, long pitch) Binds the 2D memory area pointed to by devPtr to the texture reference texref.
static int	JCuda.cudaFree(Pointer devPtr) Frees memory on the GPU.
static int	JCuda.cudaFreeHost(Pointer ptr) Frees page-locked memory.
static int	JCuda.cudaGetSymbolAddress(Pointer devPtr, java.lang.String symbol) Finds the address associated with a CUDA symbol.
static int	JCuda.cudaGLMapBufferObject(Pointer devPtr, int bufObj) Deprecated. As of CUDA 3.0
static int	JCuda.cudaGLMapBufferObjectAsync(Pointer devPtr, int bufObj, cudaStream_t stream) Deprecated. As of CUDA 3.0
static int	JCuda.cudaGraphicsResourceGetMappedPointer(Pointer devPtr, long[] size, cudaGraphicsResource resource) Returns in *devPtr a pointer through which the mapped graphics resource resource may be accessed.
static int	JCuda.cudaHostAlloc(Pointer ptr, long size, int flags) Allocates count bytes of host memory that is page-locked and accessible to the device.
static int	JCuda.cudaHostGetDevicePointer(Pointer pDevice, Pointer pHost, int flags) Passes back the device pointer corresponding to the mapped, pinned host buffer allocated by cudaHostAlloc().
static int	JCuda.cudaMalloc(Pointer devPtr, long size) Allocate memory on the GPU.
static int	JCuda.cudaMallocHost(Pointer ptr, long size) Allocates page-locked memory on the host.
static int	JCuda.cudaMallocPitch(Pointer devPtr, long[] pitch, long width, long height) Allocates memory on the GPU.
static int	JCuda.cudaMemcpy(Pointer dst, Pointer src, long count, int cudaMemcpyKind_kind) Copies data between GPU and host.
static int	JCuda.cudaMemcpy2D(Pointer dst, long dpitch, Pointer src, long spitch, long width, long height, int cudaMemcpyKind_kind) Copies data between host and device.
static int	JCuda.cudaMemcpy2DAsync(Pointer dst, long dpitch, Pointer src, long spitch, long width, long height, int cudaMemcpyKind_kind, cudaStream_t stream)
static int	JCuda.cudaMemcpy2DFromArray(Pointer dst, long dpitch, cudaArray src, long wOffset, long hOffset, long width, long height, int cudaMemcpyKind_kind) Copies data between host and device.
static int	JCuda.cudaMemcpy2DFromArrayAsync(Pointer dst, long dpitch, cudaArray src, long wOffset, long hOffset, long width, long height, int cudaMemcpyKind_kind, cudaStream_t stream)
static int	JCuda.cudaMemcpy2DToArray(cudaArray dst, long wOffset, long hOffset, Pointer src, long spitch, long width, long height, int cudaMemcpyKind_kind) Copies data between host and device.
static int	JCuda.cudaMemcpy2DToArrayAsync(cudaArray dst, long wOffset, long hOffset, Pointer src, long spitch, long width, long height, int cudaMemcpyKind_kind, cudaStream_t stream)
static int	JCuda.cudaMemcpyAsync(Pointer dst, Pointer src, long count, int cudaMemcpyKind_kind, cudaStream_t stream)
static int	JCuda.cudaMemcpyFromArray(Pointer dst, cudaArray src, long wOffset, long hOffset, long count, int cudaMemcpyKind_kind) Copies data between host and device.
static int	JCuda.cudaMemcpyFromArrayAsync(Pointer dst, cudaArray src, long wOffset, long hOffset, long count, int cudaMemcpyKind_kind, cudaStream_t stream)
static int	JCuda.cudaMemcpyFromSymbol(Pointer dst, java.lang.String symbol, long count, long offset, int cudaMemcpyKind_kind) Copies data from GPU to host memory.
static int	JCuda.cudaMemcpyFromSymbolAsync(Pointer dst, java.lang.String symbol, long count, long offset, int cudaMemcpyKind_kind, cudaStream_t stream)
static int	JCuda.cudaMemcpyToArray(cudaArray dst, long wOffset, long hOffset, Pointer src, long count, int cudaMemcpyKind_kind) Copies data between host and device.
static int	JCuda.cudaMemcpyToArrayAsync(cudaArray dst, long wOffset, long hOffset, Pointer src, long count, int cudaMemcpyKind_kind, cudaStream_t stream)
static int	JCuda.cudaMemcpyToSymbol(java.lang.String symbol, Pointer src, long count, long offset, int cudaMemcpyKind_kind) Copies data from host memory to GPU.
static int	JCuda.cudaMemcpyToSymbolAsync(java.lang.String symbol, Pointer src, long count, long offset, int cudaMemcpyKind_kind, cudaStream_t stream)
static int	JCuda.cudaMemset(Pointer mem, int c, long count) Initializes or sets GPU memory to a value.
static int	JCuda.cudaMemset2D(Pointer mem, long pitch, int c, long width, long height) Initializes or sets GPU memory to a value.
static int	JCuda.cudaSetupArgument(Pointer arg, long size, long offset) Configure a device-launch.