Uses of Class jcuda.Pointer
Date: 2010-04-21

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## 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.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES