| Package | Description |
|---|---|
| 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.jcufft |
Contains the classes of JCufft.
|
| jcuda.jcurand |
Contains the classes of JCurand.
|
| jcuda.jcusparse |
Contains the classes of JCusparse.
|
| jcuda.runtime |
Contains the classes related to the JCuda runtime API.
|
| org.nd4j.linalg.jcublas | |
| org.nd4j.linalg.jcublas.buffer | |
| org.nd4j.linalg.jcublas.util |
| Modifier and Type | Method and Description |
|---|---|
static Pointer |
Pointer.to(Buffer buffer)
NOTE: This method does not take into account the position
and array offset of 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(NativePointerObject... pointers)
Creates a new Pointer to the given Pointers.
|
static Pointer |
Pointer.to(short[] values)
Creates a new Pointer to the given values.
|
static Pointer |
Pointer.toBuffer(Buffer buffer)
Creates a new Pointer to the given buffer.
Note that this method takes into account the array offset and position of the given buffer, in contrast to the to(Buffer) method. |
Pointer |
Pointer.withByteOffset(long byteOffset)
Returns a new pointer with an offset of the given number
of bytes
|
| Constructor and Description |
|---|
Pointer(Pointer other)
Copy constructor
|
Pointer(Pointer other,
long byteOffset)
Creates a copy of the given pointer, with an
additional byte offset
|
| Modifier and Type | Class and Description |
|---|---|
class |
CUdeviceptr
Java port of a CUdeviceptr.
|
| Modifier and Type | Field and Description |
|---|---|
static Pointer |
JCudaDriver.CU_LAUNCH_PARAM_BUFFER_POINTER
Indicator that the next value in the \p extra parameter to
::cuLaunchKernel will be a pointer to a buffer containing all kernel
parameters used for launching kernel \p f.
|
static Pointer |
JCudaDriver.CU_LAUNCH_PARAM_BUFFER_SIZE
Indicator that the next value in the \p extra parameter to
::cuLaunchKernel will be a pointer to a size_t which contains the
size of the buffer specified with ::CU_LAUNCH_PARAM_BUFFER_POINTER.
|
static Pointer |
JCudaDriver.CU_LAUNCH_PARAM_END
End of array terminator for the \p extra parameter to
::cuLaunchKernel
|
Pointer |
CUDA_MEMCPY3D_PEER.dstHost
The destination pointer.
|
Pointer |
CUDA_MEMCPY2D.dstHost
The destination pointer.
|
Pointer |
CUDA_MEMCPY3D.dstHost
The destination pointer.
|
Pointer |
CUDA_MEMCPY3D_PEER.srcHost
The source pointer.
|
Pointer |
CUDA_MEMCPY2D.srcHost
The source pointer.
|
Pointer |
CUDA_MEMCPY3D.srcHost
The source pointer.
|
| Modifier and Type | Method and Description |
|---|---|
static int |
JCudaDriver.cuLaunchKernel(CUfunction f,
int gridDimX,
int gridDimY,
int gridDimZ,
int blockDimX,
int blockDimY,
int blockDimZ,
int sharedMemBytes,
CUstream hStream,
Pointer kernelParams,
Pointer extra)
Launches a CUDA function.
|
static int |
JCudaDriver.cuLinkAddData(CUlinkState state,
int type,
Pointer data,
long size,
String name,
JITOptions jitOptions) |
static int |
JCudaDriver.cuLinkComplete(CUlinkState state,
Pointer cubinOut,
long[] sizeOut) |
static int |
JCudaDriver.cuMemAllocHost(Pointer pointer,
long bytesize)
Allocates page-locked host memory.
|
static int |
JCudaDriver.cuMemcpyAtoH(Pointer dstHost,
CUarray srcArray,
long srcIndex,
long ByteCount)
Copies memory from Array to Host.
|
static int |
JCudaDriver.cuMemcpyAtoHAsync(Pointer dstHost,
CUarray srcArray,
long srcIndex,
long ByteCount,
CUstream hStream)
Copies memory from Array to Host.
|
static int |
JCudaDriver.cuMemcpyDtoH(Pointer dstHost,
CUdeviceptr srcDevice,
long ByteCount)
Copies memory from Device to Host.
|
static int |
JCudaDriver.cuMemcpyDtoHAsync(Pointer dstHost,
CUdeviceptr srcDevice,
long ByteCount,
CUstream hStream)
Copies memory from Device to Host.
|
static int |
JCudaDriver.cuMemcpyHtoA(CUarray dstArray,
long dstIndex,
Pointer pSrc,
long ByteCount)
Copies memory from Host to Array.
|
static int |
JCudaDriver.cuMemcpyHtoAAsync(CUarray dstArray,
long dstIndex,
Pointer pSrc,
long ByteCount,
CUstream hStream)
Copies memory from Host to Array.
|
static int |
JCudaDriver.cuMemcpyHtoD(CUdeviceptr dstDevice,
Pointer srcHost,
long ByteCount)
Copies memory from Host to Device.
|
static int |
JCudaDriver.cuMemcpyHtoDAsync(CUdeviceptr dstDevice,
Pointer srcHost,
long ByteCount,
CUstream hStream)
Copies memory from Host to Device.
|
static int |
JCudaDriver.cuMemFreeHost(Pointer p)
Frees page-locked host memory.
|
static int |
JCudaDriver.cuMemHostAlloc(Pointer pp,
long bytes,
int Flags)
Allocates page-locked host memory.
|
static int |
JCudaDriver.cuMemHostGetDevicePointer(CUdeviceptr ret,
Pointer p,
int Flags)
Passes back device pointer of mapped pinned memory.
|
static int |
JCudaDriver.cuMemHostGetFlags(int[] pFlags,
Pointer p)
Passes back flags that were used for a pinned allocation.
|
static int |
JCudaDriver.cuMemHostRegister(Pointer p,
long bytesize,
int Flags)
Registers an existing host memory range for use by CUDA.
|
static int |
JCudaDriver.cuMemHostUnregister(Pointer p)
Unregisters a memory range that was registered with cuMemHostRegister.
|
static int |
JCudaDriver.cuModuleLoadDataEx(CUmodule phMod,
Pointer p,
int numOptions,
int[] options,
Pointer optionValues)
Load a module's data with options.
Note: It is hardly possible to properly pass in the required option values for this method. |
static int |
JCudaDriver.cuModuleLoadDataJIT(CUmodule module,
Pointer pointer,
JITOptions jitOptions)
A wrapper function for
JCudaDriver.cuModuleLoadDataEx(CUmodule, Pointer, int, int[], Pointer)
which allows passing in the options for the JIT compiler, and obtaining
the output of the JIT compiler via a JITOptions object. |
static int |
JCudaDriver.cuParamSetv(CUfunction hfunc,
int offset,
Pointer ptr,
int numbytes)
Deprecated.
Deprecated in CUDA
|
static int |
JCudaDriver.cuPointerGetAttribute(Pointer data,
int attribute,
CUdeviceptr ptr)
Returns information about a pointer.
|
static int |
JCudaDriver.cuPointerGetAttributes(int numAttributes,
int[] attributes,
Pointer data,
CUdeviceptr ptr) |
static int |
JCudaDriver.cuPointerSetAttribute(Pointer value,
int attribute,
CUdeviceptr ptr) |
| Modifier and Type | Method and Description |
|---|---|
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 int |
JCublas2.cublasCaxpy(cublasHandle handle,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy) |
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 int |
JCublas2.cublasCcopy(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy) |
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 int |
JCublas2.cublasCdgmm(cublasHandle handle,
int mode,
int m,
int n,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer C,
int ldc) |
static int |
JCublas2.cublasCdotc(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer result)
host or device pointer
|
static cuComplex |
JCublas.cublasCdotc(int n,
Pointer x,
int incx,
Pointer y,
int incy)
cuComplex
cublasCdotc (int n, const cuComplex *x, int incx, const cuComplex *y,
int incy)
computes the dot product of two single-complex vectors.
|
static int |
JCublas2.cublasCdotu(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer result)
host or device pointer
|
static cuComplex |
JCublas.cublasCdotu(int n,
Pointer x,
int incx,
Pointer y,
int incy)
cuComplex
cdotu (int n, const cuComplex *x, int incx, const cuComplex *y, int incy)
computes the dot product of two single-complex vectors.
|
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 int |
JCublas2.cublasCgbmv(cublasHandle handle,
int trans,
int m,
int n,
int kl,
int ku,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
static int |
JCublas2.cublasCgeam(cublasHandle handle,
int transa,
int transb,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer beta,
Pointer B,
int ldb,
Pointer C,
int ldc) |
static int |
JCublas2.cublasCgelsBatched(cublasHandle handle,
int trans,
int m,
int n,
int nrhs,
Pointer Aarray,
int lda,
Pointer Carray,
int ldc,
Pointer info,
Pointer devInfoArray,
int batchSize) |
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 int |
JCublas2.cublasCgemm(cublasHandle handle,
int transa,
int transb,
int m,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasCgemmBatched(cublasHandle handle,
int transa,
int transb,
int m,
int n,
int k,
Pointer alpha,
Pointer Aarray,
int lda,
Pointer Barray,
int ldb,
Pointer beta,
Pointer Carray,
int ldc,
int batchCount) |
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 int |
JCublas2.cublasCgemv(cublasHandle handle,
int trans,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
static int |
JCublas2.cublasCgeqrfBatched(cublasHandle handle,
int m,
int n,
Pointer Aarray,
int lda,
Pointer TauArray,
Pointer info,
int batchSize) |
static int |
JCublas2.cublasCgerc(cublasHandle handle,
int m,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasCgeru(cublasHandle handle,
int m,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasCgetrfBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer P,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasCgetriBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer P,
Pointer C,
int ldc,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasCgetrsBatched(cublasHandle handle,
int trans,
int n,
int nrhs,
Pointer Aarray,
int lda,
Pointer devIpiv,
Pointer Barray,
int ldb,
Pointer info,
int batchSize) |
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 int |
JCublas2.cublasChbmv(cublasHandle handle,
int uplo,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
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 int |
JCublas2.cublasChemm(cublasHandle handle,
int side,
int uplo,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasChemv(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
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 int |
JCublas2.cublasCher(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer A,
int lda) |
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 int |
JCublas2.cublasCher2(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasCher2k(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasCherk(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasCherkx(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasChpmv(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer AP,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
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 int |
JCublas2.cublasChpr(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer AP) |
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 int |
JCublas2.cublasChpr2(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer AP) |
static int |
JCublas2.cublasCmatinvBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer Ainv,
int lda_inv,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasCrot(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer c,
Pointer s)
host or device pointer
|
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 int |
JCublas2.cublasCrotg(cublasHandle handle,
Pointer a,
Pointer b,
Pointer c,
Pointer s)
host or device pointer
|
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 int |
JCublas2.cublasCscal(cublasHandle handle,
int n,
Pointer alpha,
Pointer x,
int incx) |
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 int |
JCublas2.cublasCsrot(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer c,
Pointer s)
host or device pointer
|
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 int |
JCublas2.cublasCsscal(cublasHandle handle,
int n,
Pointer alpha,
Pointer x,
int incx) |
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 int |
JCublas2.cublasCswap(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy) |
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 int |
JCublas2.cublasCsymm(cublasHandle handle,
int side,
int uplo,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasCsymv(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
static int |
JCublas2.cublasCsyr(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer A,
int lda) |
static int |
JCublas2.cublasCsyr2(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasCsyr2k(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasCsyrk(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasCsyrkx(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasCtbmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
int k,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasCtbsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
int k,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasCtpmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer AP,
Pointer x,
int incx) |
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 int |
JCublas2.cublasCtpsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer AP,
Pointer x,
int incx) |
static int |
JCublas2.cublasCtpttr(cublasHandle handle,
int uplo,
int n,
Pointer AP,
Pointer A,
int lda) |
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 int |
JCublas2.cublasCtrmm(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasCtrmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasCtrsm(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb) |
static int |
JCublas2.cublasCtrsmBatched(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
int batchCount) |
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 int |
JCublas2.cublasCtrsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer A,
int lda,
Pointer x,
int incx) |
static int |
JCublas2.cublasCtrttp(cublasHandle handle,
int uplo,
int n,
Pointer A,
int lda,
Pointer AP) |
static int |
JCublas2.cublasDasum(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 int |
JCublas2.cublasDaxpy(cublasHandle handle,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy) |
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 int |
JCublas2.cublasDcopy(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy) |
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 int |
JCublas2.cublasDdgmm(cublasHandle handle,
int mode,
int m,
int n,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer C,
int ldc) |
static int |
JCublas2.cublasDdot(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer result)
host or device pointer
|
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 int |
JCublas2.cublasDgbmv(cublasHandle handle,
int trans,
int m,
int n,
int kl,
int ku,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
static int |
JCublas2.cublasDgeam(cublasHandle handle,
int transa,
int transb,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer beta,
Pointer B,
int ldb,
Pointer C,
int ldc) |
static int |
JCublas2.cublasDgelsBatched(cublasHandle handle,
int trans,
int m,
int n,
int nrhs,
Pointer Aarray,
int lda,
Pointer Carray,
int ldc,
Pointer info,
Pointer devInfoArray,
int batchSize) |
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 int |
JCublas2.cublasDgemm(cublasHandle handle,
int transa,
int transb,
int m,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasDgemmBatched(cublasHandle handle,
int transa,
int transb,
int m,
int n,
int k,
Pointer alpha,
Pointer Aarray,
int lda,
Pointer Barray,
int ldb,
Pointer beta,
Pointer Carray,
int ldc,
int batchCount) |
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 int |
JCublas2.cublasDgemv(cublasHandle handle,
int trans,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
static int |
JCublas2.cublasDgeqrfBatched(cublasHandle handle,
int m,
int n,
Pointer Aarray,
int lda,
Pointer TauArray,
Pointer info,
int batchSize) |
static int |
JCublas2.cublasDger(cublasHandle handle,
int m,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasDgetrfBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer P,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasDgetriBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer P,
Pointer C,
int ldc,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasDgetrsBatched(cublasHandle handle,
int trans,
int n,
int nrhs,
Pointer Aarray,
int lda,
Pointer devIpiv,
Pointer Barray,
int ldb,
Pointer info,
int batchSize) |
static int |
JCublas2.cublasDmatinvBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer Ainv,
int lda_inv,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasDnrm2(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 int |
JCublas2.cublasDrot(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer c,
Pointer s)
host or device pointer
|
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 int |
JCublas2.cublasDrotg(cublasHandle handle,
Pointer a,
Pointer b,
Pointer c,
Pointer s)
host or device pointer
|
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 int |
JCublas2.cublasDrotm(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer param)
host or device pointer
|
static void |
JCublas.cublasDrotm(int n,
Pointer x,
int incx,
Pointer y,
int incy,
double[] sparam)
Wrapper for CUBLAS function.
|
static int |
JCublas2.cublasDrotmg(cublasHandle handle,
Pointer d1,
Pointer d2,
Pointer x1,
Pointer y1,
Pointer param)
host or device pointer
|
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 int |
JCublas2.cublasDsbmv(cublasHandle handle,
int uplo,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
static int |
JCublas2.cublasDscal(cublasHandle handle,
int n,
Pointer alpha,
Pointer x,
int incx) |
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 int |
JCublas2.cublasDspmv(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer AP,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
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 int |
JCublas2.cublasDspr(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer AP) |
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 int |
JCublas2.cublasDspr2(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer AP) |
static int |
JCublas2.cublasDswap(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy) |
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)
interchanges the double-precision vector x with the double-precision vector y.
|
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 int |
JCublas2.cublasDsymm(cublasHandle handle,
int side,
int uplo,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasDsymv(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
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 int |
JCublas2.cublasDsyr(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer A,
int lda) |
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 int |
JCublas2.cublasDsyr2(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasDsyr2k(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasDsyrk(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasDsyrkx(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasDtbmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
int k,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasDtbsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
int k,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasDtpmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer AP,
Pointer x,
int incx) |
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 int |
JCublas2.cublasDtpsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer AP,
Pointer x,
int incx) |
static int |
JCublas2.cublasDtpttr(cublasHandle handle,
int uplo,
int n,
Pointer AP,
Pointer A,
int lda) |
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 int |
JCublas2.cublasDtrmm(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasDtrmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasDtrsm(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb) |
static int |
JCublas2.cublasDtrsmBatched(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
int batchCount) |
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 int |
JCublas2.cublasDtrsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer A,
int lda,
Pointer x,
int incx) |
static int |
JCublas2.cublasDtrttp(cublasHandle handle,
int uplo,
int n,
Pointer A,
int lda,
Pointer AP) |
static int |
JCublas2.cublasDzasum(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 int |
JCublas2.cublasDznrm2(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 |
JCublas2.cublasGetMatrix(int rows,
int cols,
int elemSize,
Pointer A,
int lda,
Pointer B,
int ldb)
cublasStatus_t
cublasGetMatrix (int rows, int cols, int elemSize, const void *A,
int lda, void *B, int ldb)
copies a tile of rows x cols elements from a matrix A in GPU memory
space to a matrix B in CPU memory space.
|
static int |
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 |
JCublas2.cublasGetMatrixAsync(int rows,
int cols,
int elemSize,
Pointer A,
int lda,
Pointer B,
int ldb,
cudaStream_t stream)
cublasStatus_t
cublasGetMatrixAsync (int rows, int cols, int elemSize, const void *A,
int lda, void *B, int ldb, cudaStream_t stream)
cublasGetMatrixAsync has the same functionnality as cublasGetMatrix
but the transfer is done asynchronously within the CUDA stream passed
in parameter.
|
static int |
JCublas.cublasGetMatrixAsync(int rows,
int cols,
int elemSize,
Pointer A,
int lda,
Pointer B,
int ldb,
cudaStream_t stream) |
static int |
JCublas2.cublasGetVector(int n,
int elemSize,
Pointer x,
int incx,
Pointer y,
int incy)
cublasStatus_t
cublasGetVector (int n, int elemSize, const void *x, int incx,
void *y, int incy)
copies n elements from a vector x in GPU memory space to a vector y
in CPU memory space.
|
static int |
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 |
JCublas2.cublasGetVectorAsync(int n,
int elemSize,
Pointer devicePtr,
int incx,
Pointer hostPtr,
int incy,
cudaStream_t stream)
cublasStatus
cublasGetVectorAsync( int n, int elemSize, const void *x, int incx,
void *y, int incy, cudaStream_t stream)
cublasGetVectorAsync has the same functionnality as cublasGetVector
but the transfer is done asynchronously within the CUDA stream passed
in parameter.
|
static int |
JCublas.cublasGetVectorAsync(int n,
int elemSize,
Pointer devicePtr,
int incx,
Pointer hostPtr,
int incy,
cudaStream_t stream) |
static int |
JCublas2.cublasIcamax(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 |
JCublas2.cublasIcamin(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 |
JCublas2.cublasIdamax(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 |
JCublas2.cublasIdamin(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 |
JCublas2.cublasIsamax(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result) |
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 |
JCublas2.cublasIsamin(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 |
JCublas2.cublasIzamax(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 |
JCublas2.cublasIzamin(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 int |
JCublas2.cublasSasum(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 int |
JCublas2.cublasSaxpy(cublasHandle handle,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy) |
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 int |
JCublas2.cublasScasum(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 int |
JCublas2.cublasScnrm2(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result)
host or device pointer
|
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 int |
JCublas2.cublasScopy(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy) |
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 int |
JCublas2.cublasSdgmm(cublasHandle handle,
int mode,
int m,
int n,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer C,
int ldc) |
static int |
JCublas2.cublasSdot(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer result)
host or device pointer
|
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 |
JCublas2.cublasSetMatrix(int rows,
int cols,
int elemSize,
Pointer A,
int lda,
Pointer B,
int ldb)
cublasStatus_t
cublasSetMatrix (int rows, int cols, int elemSize, const void *A,
int lda, void *B, int ldb)
copies a tile of rows x cols elements from a matrix A in CPU memory
space to a matrix B in GPU memory space.
|
static int |
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 |
JCublas2.cublasSetMatrixAsync(int rows,
int cols,
int elemSize,
Pointer A,
int lda,
Pointer B,
int ldb,
cudaStream_t stream)
cublasStatus_t
cublasSetMatrixAsync (int rows, int cols, int elemSize, const void *A,
int lda, void *B, int ldb, cudaStream_t stream)
cublasSetMatrixAsync has the same functionnality as cublasSetMatrix
but the transfer is done asynchronously within the CUDA stream passed
in parameter.
|
static int |
JCublas.cublasSetMatrixAsync(int rows,
int cols,
int elemSize,
Pointer A,
int lda,
Pointer B,
int ldb,
cudaStream_t stream) |
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 |
JCublas2.cublasSetVector(int n,
int elemSize,
Pointer x,
int incx,
Pointer devicePtr,
int incy)
cublasStatus_t
cublasSetVector (int n, int elemSize, const void *x, int incx,
void *y, int incy)
copies n elements from a vector x in CPU memory space to a vector y
in GPU memory space.
|
static int |
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 int |
JCublas2.cublasSetVectorAsync(int n,
int elemSize,
Pointer hostPtr,
int incx,
Pointer devicePtr,
int incy,
cudaStream_t stream)
cublasStatus
cublasSetVectorAsync ( int n, int elemSize, const void *x, int incx,
void *y, int incy, cudaStream_t stream );
cublasSetVectorAsync has the same functionnality as cublasSetVector
but the transfer is done asynchronously within the CUDA stream passed
in parameter.
|
static int |
JCublas.cublasSetVectorAsync(int n,
int elemSize,
Pointer hostPtr,
int incx,
Pointer devicePtr,
int incy,
cudaStream_t stream) |
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 int |
JCublas2.cublasSgbmv(cublasHandle handle,
int trans,
int m,
int n,
int kl,
int ku,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
static int |
JCublas2.cublasSgeam(cublasHandle handle,
int transa,
int transb,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer beta,
Pointer B,
int ldb,
Pointer C,
int ldc) |
static int |
JCublas2.cublasSgelsBatched(cublasHandle handle,
int trans,
int m,
int n,
int nrhs,
Pointer Aarray,
int lda,
Pointer Carray,
int ldc,
Pointer info,
Pointer devInfoArray,
int batchSize) |
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 int |
JCublas2.cublasSgemm(cublasHandle handle,
int transa,
int transb,
int m,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasSgemmBatched(cublasHandle handle,
int transa,
int transb,
int m,
int n,
int k,
Pointer alpha,
Pointer Aarray,
int lda,
Pointer Barray,
int ldb,
Pointer beta,
Pointer Carray,
int ldc,
int batchCount) |
static int |
JCublas2.cublasSgemmEx(cublasHandle handle,
int transa,
int transb,
int m,
int n,
int k,
Pointer alpha,
Pointer A,
int Atype,
int lda,
Pointer B,
int Btype,
int ldb,
Pointer beta,
Pointer C,
int Ctype,
int ldc) |
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 int |
JCublas2.cublasSgemv(cublasHandle handle,
int trans,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy)
host or device pointer
|
static int |
JCublas2.cublasSgeqrfBatched(cublasHandle handle,
int m,
int n,
Pointer Aarray,
int lda,
Pointer TauArray,
Pointer info,
int batchSize) |
static int |
JCublas2.cublasSger(cublasHandle handle,
int m,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasSgetrfBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer P,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasSgetriBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer P,
Pointer C,
int ldc,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasSgetrsBatched(cublasHandle handle,
int trans,
int n,
int nrhs,
Pointer Aarray,
int lda,
Pointer devIpiv,
Pointer Barray,
int ldb,
Pointer info,
int batchSize) |
static int |
JCublas2.cublasSmatinvBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer Ainv,
int lda_inv,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasSnrm2(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer result) |
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 int |
JCublas2.cublasSrot(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer c,
Pointer s)
host or device pointer
|
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 int |
JCublas2.cublasSrotg(cublasHandle handle,
Pointer a,
Pointer b,
Pointer c,
Pointer s)
host or device pointer
|
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 int |
JCublas2.cublasSrotm(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer param)
host or device pointer
|
static void |
JCublas.cublasSrotm(int n,
Pointer x,
int incx,
Pointer y,
int incy,
float[] sparam)
Wrapper for CUBLAS function.
|
static int |
JCublas2.cublasSrotmg(cublasHandle handle,
Pointer d1,
Pointer d2,
Pointer x1,
Pointer y1,
Pointer param)
host or device pointer
|
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 int |
JCublas2.cublasSsbmv(cublasHandle handle,
int uplo,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
static int |
JCublas2.cublasSscal(cublasHandle handle,
int n,
Pointer alpha,
Pointer x,
int incx)
host or device pointer
|
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 int |
JCublas2.cublasSspmv(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer AP,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
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 int |
JCublas2.cublasSspr(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer AP) |
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 int |
JCublas2.cublasSspr2(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer AP) |
static int |
JCublas2.cublasSswap(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy) |
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)
interchanges the single-precision vector x with the single-precision vector y.
|
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 int |
JCublas2.cublasSsymm(cublasHandle handle,
int side,
int uplo,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasSsymv(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
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 int |
JCublas2.cublasSsyr(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer A,
int lda) |
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 int |
JCublas2.cublasSsyr2(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasSsyr2k(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasSsyrk(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasSsyrkx(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasStbmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
int k,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasStbsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
int k,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasStpmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer AP,
Pointer x,
int incx) |
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 int |
JCublas2.cublasStpsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer AP,
Pointer x,
int incx) |
static int |
JCublas2.cublasStpttr(cublasHandle handle,
int uplo,
int n,
Pointer AP,
Pointer A,
int lda) |
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 int |
JCublas2.cublasStrmm(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasStrmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasStrsm(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb) |
static int |
JCublas2.cublasStrsmBatched(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
int batchCount) |
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 int |
JCublas2.cublasStrsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer A,
int lda,
Pointer x,
int incx) |
static int |
JCublas2.cublasStrttp(cublasHandle handle,
int uplo,
int n,
Pointer A,
int lda,
Pointer AP) |
static int |
JCublas2.cublasZaxpy(cublasHandle handle,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy) |
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 int |
JCublas2.cublasZcopy(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy) |
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 int |
JCublas2.cublasZdgmm(cublasHandle handle,
int mode,
int m,
int n,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer C,
int ldc) |
static int |
JCublas2.cublasZdotc(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer result)
host or device pointer
|
static cuDoubleComplex |
JCublas.cublasZdotc(int n,
Pointer x,
int incx,
Pointer y,
int incy)
cuDoubleComplex
cublasZdotc (int n, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, int incy)
computes the dot product of two double-precision complex vectors.
|
static int |
JCublas2.cublasZdotu(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer result)
host or device pointer
|
static cuDoubleComplex |
JCublas.cublasZdotu(int n,
Pointer x,
int incx,
Pointer y,
int incy)
cuDoubleComplex
zdotu (int n, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, int incy)
computes the dot product of two double-complex vectors.
|
static int |
JCublas2.cublasZdrot(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer c,
Pointer s)
host or device pointer
|
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 int |
JCublas2.cublasZdscal(cublasHandle handle,
int n,
Pointer alpha,
Pointer x,
int incx) |
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 int |
JCublas2.cublasZgbmv(cublasHandle handle,
int trans,
int m,
int n,
int kl,
int ku,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
static int |
JCublas2.cublasZgeam(cublasHandle handle,
int transa,
int transb,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer beta,
Pointer B,
int ldb,
Pointer C,
int ldc) |
static int |
JCublas2.cublasZgelsBatched(cublasHandle handle,
int trans,
int m,
int n,
int nrhs,
Pointer Aarray,
int lda,
Pointer Carray,
int ldc,
Pointer info,
Pointer devInfoArray,
int batchSize) |
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 int |
JCublas2.cublasZgemm(cublasHandle handle,
int transa,
int transb,
int m,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasZgemmBatched(cublasHandle handle,
int transa,
int transb,
int m,
int n,
int k,
Pointer alpha,
Pointer Aarray,
int lda,
Pointer Barray,
int ldb,
Pointer beta,
Pointer Carray,
int ldc,
int batchCount) |
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 int |
JCublas2.cublasZgemv(cublasHandle handle,
int trans,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
static int |
JCublas2.cublasZgeqrfBatched(cublasHandle handle,
int m,
int n,
Pointer Aarray,
int lda,
Pointer TauArray,
Pointer info,
int batchSize) |
static int |
JCublas2.cublasZgerc(cublasHandle handle,
int m,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasZgeru(cublasHandle handle,
int m,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasZgetrfBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer P,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasZgetriBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer P,
Pointer C,
int ldc,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasZgetrsBatched(cublasHandle handle,
int trans,
int n,
int nrhs,
Pointer Aarray,
int lda,
Pointer devIpiv,
Pointer Barray,
int ldb,
Pointer info,
int batchSize) |
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 int |
JCublas2.cublasZhbmv(cublasHandle handle,
int uplo,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
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 int |
JCublas2.cublasZhemm(cublasHandle handle,
int side,
int uplo,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasZhemv(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
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 int |
JCublas2.cublasZher(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer A,
int lda) |
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 int |
JCublas2.cublasZher2(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasZher2k(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasZherk(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasZherkx(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasZhpmv(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer AP,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
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 int |
JCublas2.cublasZhpr(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer AP) |
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 int |
JCublas2.cublasZhpr2(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer AP) |
static int |
JCublas2.cublasZmatinvBatched(cublasHandle handle,
int n,
Pointer A,
int lda,
Pointer Ainv,
int lda_inv,
Pointer INFO,
int batchSize) |
static int |
JCublas2.cublasZrot(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer c,
Pointer s)
host or device pointer
|
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 int |
JCublas2.cublasZrotg(cublasHandle handle,
Pointer a,
Pointer b,
Pointer c,
Pointer s)
host or device pointer
|
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 int |
JCublas2.cublasZscal(cublasHandle handle,
int n,
Pointer alpha,
Pointer x,
int incx) |
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 int |
JCublas2.cublasZswap(cublasHandle handle,
int n,
Pointer x,
int incx,
Pointer y,
int incy) |
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 int |
JCublas2.cublasZsymm(cublasHandle handle,
int side,
int uplo,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasZsymv(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer x,
int incx,
Pointer beta,
Pointer y,
int incy) |
static int |
JCublas2.cublasZsyr(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer A,
int lda) |
static int |
JCublas2.cublasZsyr2(cublasHandle handle,
int uplo,
int n,
Pointer alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda) |
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 int |
JCublas2.cublasZsyr2k(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasZsyrk(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCublas2.cublasZsyrkx(cublasHandle handle,
int uplo,
int trans,
int n,
int k,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasZtbmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
int k,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasZtbsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
int k,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasZtpmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer AP,
Pointer x,
int incx) |
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 int |
JCublas2.cublasZtpsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer AP,
Pointer x,
int incx) |
static int |
JCublas2.cublasZtpttr(cublasHandle handle,
int uplo,
int n,
Pointer AP,
Pointer A,
int lda) |
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 int |
JCublas2.cublasZtrmm(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
Pointer C,
int ldc) |
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 int |
JCublas2.cublasZtrmv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer A,
int lda,
Pointer x,
int incx) |
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 int |
JCublas2.cublasZtrsm(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb) |
static int |
JCublas2.cublasZtrsmBatched(cublasHandle handle,
int side,
int uplo,
int trans,
int diag,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
int batchCount) |
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 int |
JCublas2.cublasZtrsv(cublasHandle handle,
int uplo,
int trans,
int diag,
int n,
Pointer A,
int lda,
Pointer x,
int incx) |
static int |
JCublas2.cublasZtrttp(cublasHandle handle,
int uplo,
int n,
Pointer A,
int lda,
Pointer AP) |
static void |
JCublas.printMatrix(int cols,
Pointer A,
int lda) |
static void |
JCublas.printVector(int n,
Pointer x) |
| Modifier and Type | Method and Description |
|---|---|
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.
|
static int |
JCufft.cufftSetWorkArea(cufftHandle plan,
Pointer workArea) |
| Modifier and Type | Method and Description |
|---|---|
static int |
JCurand.curandGenerate(curandGenerator generator,
Pointer outputPtr,
long num)
Generate 32-bit pseudo or quasirandom numbers.
|
static int |
JCurand.curandGenerateLogNormal(curandGenerator generator,
Pointer outputPtr,
long n,
float mean,
float stddev)
Generate log-normally distributed floats.
|
static int |
JCurand.curandGenerateLogNormalDouble(curandGenerator generator,
Pointer outputPtr,
long n,
double mean,
double stddev)
Generate log-normally distributed doubles.
|
static int |
JCurand.curandGenerateLongLong(curandGenerator generator,
Pointer outputPtr,
long num)
Generate 64-bit quasirandom numbers.
|
static int |
JCurand.curandGenerateNormal(curandGenerator generator,
Pointer outputPtr,
long n,
float mean,
float stddev)
Generate normally distributed floats.
|
static int |
JCurand.curandGenerateNormalDouble(curandGenerator generator,
Pointer outputPtr,
long n,
double mean,
double stddev)
Generate normally distributed doubles.
|
static int |
JCurand.curandGeneratePoisson(curandGenerator generator,
Pointer outputPtr,
long n,
double lambda)
Generate Poisson-distributed unsigned ints.
|
static int |
JCurand.curandGenerateUniform(curandGenerator generator,
Pointer outputPtr,
long num)
Generate uniformly distributed floats.
|
static int |
JCurand.curandGenerateUniformDouble(curandGenerator generator,
Pointer outputPtr,
long num)
Generate uniformly distributed doubles.
|
| Modifier and Type | Method and Description |
|---|---|
static int |
JCusparse.cusparseCaxpyi(cusparseHandle handle,
int nnz,
Pointer alpha,
Pointer xVal,
Pointer xInd,
Pointer y,
int idxBase) |
static int |
JCusparse.cusparseCbsr2csr(cusparseHandle handle,
int dirA,
int mb,
int nb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseCbsric02_analysis(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
int policy,
Pointer pInputBuffer) |
static int |
JCusparse.cusparseCbsric02_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseCbsric02_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsric02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseCbsric02(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCbsrilu02_analysis(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCbsrilu02_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseCbsrilu02_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrilu02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseCbsrilu02_numericBoost(cusparseHandle handle,
bsrilu02Info info,
int enable_boost,
Pointer tol,
Pointer boost_val) |
static int |
JCusparse.cusparseCbsrilu02(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descra,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCbsrmm(cusparseHandle handle,
int dirA,
int transA,
int transB,
int mb,
int n,
int kb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockSize,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCusparse.cusparseCbsrmv(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseCbsrsm2_analysis(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCbsrsm2_bufferSize(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseCbsrsm2_bufferSizeExt(cusparseHandle handle,
int dirA,
int transA,
int transB,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseCbsrsm2_solve(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
Pointer F,
int ldf,
Pointer X,
int ldx,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCbsrsv2_analysis(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCbsrsv2_bufferSize(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseCbsrsv2_bufferSizeExt(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockSize,
bsrsv2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseCbsrsv2_solve(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
Pointer f,
Pointer x,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCbsrxmv(cusparseHandle handle,
int dirA,
int transA,
int sizeOfMask,
int mb,
int nb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedMaskPtrA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedEndPtrA,
Pointer bsrSortedColIndA,
int blockDim,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseCcsc2dense(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA,
Pointer A,
int lda) |
static int |
JCusparse.cusparseCcsc2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA,
cusparseHybMat hybA,
int userEllWidth,
int partitionType) |
static int |
JCusparse.cusparseCcsr2bsr(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int blockDim,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC) |
static int |
JCusparse.cusparseCcsr2csc(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
Pointer cscSortedVal,
Pointer cscSortedRowInd,
Pointer cscSortedColPtr,
int copyValues,
int idxBase) |
static int |
JCusparse.cusparseCcsr2csru(cusparseHandle handle,
int m,
int n,
int nnz,
cusparseMatDescr descrA,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
Pointer pBuffer) |
static int |
JCusparse.cusparseCcsr2dense(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer A,
int lda) |
static int |
JCusparse.cusparseCcsr2gebsr_bufferSize(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseCcsr2gebsr_bufferSizeExt(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
long[] pBufferSize) |
static int |
JCusparse.cusparseCcsr2gebsr(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC,
int rowBlockDim,
int colBlockDim,
Pointer pBuffer) |
static int |
JCusparse.cusparseCcsr2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseHybMat hybA,
int userEllWidth,
int partitionType) |
static int |
JCusparse.cusparseCcsrcolor(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer fractionToColor,
Pointer ncolors,
Pointer coloring,
Pointer reordering,
cusparseColorInfo info) |
static int |
JCusparse.cusparseCcsrgeam(cusparseHandle handle,
int m,
int n,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer beta,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseCcsrgemm(cusparseHandle handle,
int transA,
int transB,
int m,
int n,
int k,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseCcsrgemm2_bufferSizeExt(cusparseHandle handle,
int m,
int n,
int k,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
Pointer beta,
cusparseMatDescr descrD,
int nnzD,
Pointer csrSortedRowPtrD,
Pointer csrSortedColIndD,
csrgemm2Info info,
long[] pBufferSizeInBytes) |
static int |
JCusparse.cusparseCcsrgemm2(cusparseHandle handle,
int m,
int n,
int k,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
Pointer beta,
cusparseMatDescr descrD,
int nnzD,
Pointer csrSortedValD,
Pointer csrSortedRowPtrD,
Pointer csrSortedColIndD,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC,
csrgemm2Info info,
Pointer pBuffer) |
static int |
JCusparse.cusparseCcsric0(cusparseHandle handle,
int trans,
int m,
cusparseMatDescr descrA,
Pointer csrSortedValA_ValM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseCcsric02_analysis(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCcsric02_bufferSize(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseCcsric02_bufferSizeExt(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
csric02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseCcsric02(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA_valM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCcsrilu0(cusparseHandle handle,
int trans,
int m,
cusparseMatDescr descrA,
Pointer csrSortedValA_ValM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseCcsrilu02_analysis(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCcsrilu02_bufferSize(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseCcsrilu02_bufferSizeExt(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
csrilu02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseCcsrilu02_numericBoost(cusparseHandle handle,
csrilu02Info info,
int enable_boost,
Pointer tol,
Pointer boost_val) |
static int |
JCusparse.cusparseCcsrilu02(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA_valM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCcsrmm(cusparseHandle handle,
int transA,
int m,
int n,
int k,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCusparse.cusparseCcsrmm2(cusparseHandle handle,
int transA,
int transB,
int m,
int n,
int k,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCusparse.cusparseCcsrmv(cusparseHandle handle,
int transA,
int m,
int n,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseCcsrsm_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseCcsrsm_solve(cusparseHandle handle,
int transA,
int m,
int n,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info,
Pointer F,
int ldf,
Pointer X,
int ldx) |
static int |
JCusparse.cusparseCcsrsv_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseCcsrsv_solve(cusparseHandle handle,
int transA,
int m,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info,
Pointer f,
Pointer x) |
static int |
JCusparse.cusparseCcsrsv2_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCcsrsv2_bufferSize(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseCcsrsv2_bufferSizeExt(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseCcsrsv2_solve(cusparseHandle handle,
int transA,
int m,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
Pointer f,
Pointer x,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseCcsru2csr_bufferSizeExt(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
long[] pBufferSizeInBytes) |
static int |
JCusparse.cusparseCcsru2csr(cusparseHandle handle,
int m,
int n,
int nnz,
cusparseMatDescr descrA,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
Pointer pBuffer) |
static int |
JCusparse.cusparseCdense2csc(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerCol,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA) |
static int |
JCusparse.cusparseCdense2csr(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRow,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA) |
static int |
JCusparse.cusparseCdense2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRow,
cusparseHybMat hybA,
int userEllWidth,
int partitionType) |
static int |
JCusparse.cusparseCdotci(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
Pointer resultDevHostPtr,
int idxBase)
Description: dot product of complex conjugate of a sparse vector x
and a dense vector y.
|
static int |
JCusparse.cusparseCdoti(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
Pointer resultDevHostPtr,
int idxBase) |
static int |
JCusparse.cusparseCgebsr2csr(cusparseHandle handle,
int dirA,
int mb,
int nb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDim,
int colBlockDim,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseCgebsr2gebsc_bufferSize(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseCgebsr2gebsc_bufferSizeExt(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
long[] pBufferSize) |
static int |
JCusparse.cusparseCgebsr2gebsc(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
Pointer bscVal,
Pointer bscRowInd,
Pointer bscColPtr,
int copyValues,
int baseIdx,
Pointer pBuffer) |
static int |
JCusparse.cusparseCgebsr2gebsr_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseCgebsr2gebsr_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
long[] pBufferSize) |
static int |
JCusparse.cusparseCgebsr2gebsr(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC,
int rowBlockDimC,
int colBlockDimC,
Pointer pBuffer) |
static int |
JCusparse.cusparseCgemvi_bufferSize(cusparseHandle handle,
int transA,
int m,
int n,
int nnz,
Pointer pBufferSize) |
static int |
JCusparse.cusparseCgemvi(cusparseHandle handle,
int transA,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer beta,
Pointer y,
int idxBase,
Pointer pBuffer) |
static int |
JCusparse.cusparseCgthr(cusparseHandle handle,
int nnz,
Pointer y,
Pointer xVal,
Pointer xInd,
int idxBase) |
static int |
JCusparse.cusparseCgthrz(cusparseHandle handle,
int nnz,
Pointer y,
Pointer xVal,
Pointer xInd,
int idxBase) |
static int |
JCusparse.cusparseCgtsv_nopivot(cusparseHandle handle,
int m,
int n,
Pointer dl,
Pointer d,
Pointer du,
Pointer B,
int ldb) |
static int |
JCusparse.cusparseCgtsv(cusparseHandle handle,
int m,
int n,
Pointer dl,
Pointer d,
Pointer du,
Pointer B,
int ldb) |
static int |
JCusparse.cusparseCgtsvStridedBatch(cusparseHandle handle,
int m,
Pointer dl,
Pointer d,
Pointer du,
Pointer x,
int batchCount,
int batchStride) |
static int |
JCusparse.cusparseChyb2csc(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer cscSortedVal,
Pointer cscSortedRowInd,
Pointer cscSortedColPtr) |
static int |
JCusparse.cusparseChyb2csr(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA) |
static int |
JCusparse.cusparseChyb2dense(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer A,
int lda) |
static int |
JCusparse.cusparseChybmv(cusparseHandle handle,
int transA,
Pointer alpha,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseChybsv_solve(cusparseHandle handle,
int trans,
Pointer alpha,
cusparseMatDescr descra,
cusparseHybMat hybA,
cusparseSolveAnalysisInfo info,
Pointer f,
Pointer x) |
static int |
JCusparse.cusparseCnnz(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRowCol,
Pointer nnzTotalDevHostPtr) |
static int |
JCusparse.cusparseCreateIdentityPermutation(cusparseHandle handle,
int n,
Pointer p)
Description: Create a identity sequence p=[0,1,...,n-1].
|
static int |
JCusparse.cusparseCsctr(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
int idxBase) |
static int |
JCusparse.cusparseDaxpyi(cusparseHandle handle,
int nnz,
Pointer alpha,
Pointer xVal,
Pointer xInd,
Pointer y,
int idxBase) |
static int |
JCusparse.cusparseDbsr2csr(cusparseHandle handle,
int dirA,
int mb,
int nb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseDbsric02_analysis(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
int policy,
Pointer pInputBuffer) |
static int |
JCusparse.cusparseDbsric02_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseDbsric02_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsric02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseDbsric02(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDbsrilu02_analysis(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDbsrilu02_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseDbsrilu02_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrilu02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseDbsrilu02_numericBoost(cusparseHandle handle,
bsrilu02Info info,
int enable_boost,
Pointer tol,
Pointer boost_val) |
static int |
JCusparse.cusparseDbsrilu02(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descra,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDbsrmm(cusparseHandle handle,
int dirA,
int transA,
int transB,
int mb,
int n,
int kb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockSize,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCusparse.cusparseDbsrmv(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseDbsrsm2_analysis(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDbsrsm2_bufferSize(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseDbsrsm2_bufferSizeExt(cusparseHandle handle,
int dirA,
int transA,
int transB,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseDbsrsm2_solve(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
Pointer F,
int ldf,
Pointer X,
int ldx,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDbsrsv2_analysis(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDbsrsv2_bufferSize(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseDbsrsv2_bufferSizeExt(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockSize,
bsrsv2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseDbsrsv2_solve(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
Pointer f,
Pointer x,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDbsrxmv(cusparseHandle handle,
int dirA,
int transA,
int sizeOfMask,
int mb,
int nb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedMaskPtrA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedEndPtrA,
Pointer bsrSortedColIndA,
int blockDim,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseDcsc2dense(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA,
Pointer A,
int lda) |
static int |
JCusparse.cusparseDcsc2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA,
cusparseHybMat hybA,
int userEllWidth,
int partitionType) |
static int |
JCusparse.cusparseDcsr2bsr(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int blockDim,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC) |
static int |
JCusparse.cusparseDcsr2csc(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
Pointer cscSortedVal,
Pointer cscSortedRowInd,
Pointer cscSortedColPtr,
int copyValues,
int idxBase) |
static int |
JCusparse.cusparseDcsr2csru(cusparseHandle handle,
int m,
int n,
int nnz,
cusparseMatDescr descrA,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
Pointer pBuffer) |
static int |
JCusparse.cusparseDcsr2dense(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer A,
int lda) |
static int |
JCusparse.cusparseDcsr2gebsr_bufferSize(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseDcsr2gebsr_bufferSizeExt(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
long[] pBufferSize) |
static int |
JCusparse.cusparseDcsr2gebsr(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC,
int rowBlockDim,
int colBlockDim,
Pointer pBuffer) |
static int |
JCusparse.cusparseDcsr2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseHybMat hybA,
int userEllWidth,
int partitionType) |
static int |
JCusparse.cusparseDcsrcolor(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer fractionToColor,
Pointer ncolors,
Pointer coloring,
Pointer reordering,
cusparseColorInfo info) |
static int |
JCusparse.cusparseDcsrgeam(cusparseHandle handle,
int m,
int n,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer beta,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseDcsrgemm(cusparseHandle handle,
int transA,
int transB,
int m,
int n,
int k,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseDcsrgemm2_bufferSizeExt(cusparseHandle handle,
int m,
int n,
int k,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
Pointer beta,
cusparseMatDescr descrD,
int nnzD,
Pointer csrSortedRowPtrD,
Pointer csrSortedColIndD,
csrgemm2Info info,
long[] pBufferSizeInBytes) |
static int |
JCusparse.cusparseDcsrgemm2(cusparseHandle handle,
int m,
int n,
int k,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
Pointer beta,
cusparseMatDescr descrD,
int nnzD,
Pointer csrSortedValD,
Pointer csrSortedRowPtrD,
Pointer csrSortedColIndD,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC,
csrgemm2Info info,
Pointer pBuffer) |
static int |
JCusparse.cusparseDcsric0(cusparseHandle handle,
int trans,
int m,
cusparseMatDescr descrA,
Pointer csrSortedValA_ValM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseDcsric02_analysis(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDcsric02_bufferSize(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseDcsric02_bufferSizeExt(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
csric02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseDcsric02(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA_valM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDcsrilu0(cusparseHandle handle,
int trans,
int m,
cusparseMatDescr descrA,
Pointer csrSortedValA_ValM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseDcsrilu02_analysis(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDcsrilu02_bufferSize(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseDcsrilu02_bufferSizeExt(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
csrilu02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseDcsrilu02_numericBoost(cusparseHandle handle,
csrilu02Info info,
int enable_boost,
Pointer tol,
Pointer boost_val) |
static int |
JCusparse.cusparseDcsrilu02(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA_valM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDcsrmm(cusparseHandle handle,
int transA,
int m,
int n,
int k,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCusparse.cusparseDcsrmm2(cusparseHandle handle,
int transA,
int transB,
int m,
int n,
int k,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCusparse.cusparseDcsrmv(cusparseHandle handle,
int transA,
int m,
int n,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseDcsrsm_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseDcsrsm_solve(cusparseHandle handle,
int transA,
int m,
int n,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info,
Pointer F,
int ldf,
Pointer X,
int ldx) |
static int |
JCusparse.cusparseDcsrsv_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseDcsrsv_solve(cusparseHandle handle,
int transA,
int m,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info,
Pointer f,
Pointer x) |
static int |
JCusparse.cusparseDcsrsv2_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDcsrsv2_bufferSize(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseDcsrsv2_bufferSizeExt(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseDcsrsv2_solve(cusparseHandle handle,
int transA,
int m,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
Pointer f,
Pointer x,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseDcsru2csr_bufferSizeExt(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
long[] pBufferSizeInBytes) |
static int |
JCusparse.cusparseDcsru2csr(cusparseHandle handle,
int m,
int n,
int nnz,
cusparseMatDescr descrA,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
Pointer pBuffer) |
static int |
JCusparse.cusparseDdense2csc(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerCol,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA) |
static int |
JCusparse.cusparseDdense2csr(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRow,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA) |
static int |
JCusparse.cusparseDdense2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRow,
cusparseHybMat hybA,
int userEllWidth,
int partitionType) |
static int |
JCusparse.cusparseDdoti(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
Pointer resultDevHostPtr,
int idxBase) |
static int |
JCusparse.cusparseDgebsr2csr(cusparseHandle handle,
int dirA,
int mb,
int nb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDim,
int colBlockDim,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseDgebsr2gebsc_bufferSize(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseDgebsr2gebsc_bufferSizeExt(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
long[] pBufferSize) |
static int |
JCusparse.cusparseDgebsr2gebsc(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
Pointer bscVal,
Pointer bscRowInd,
Pointer bscColPtr,
int copyValues,
int baseIdx,
Pointer pBuffer) |
static int |
JCusparse.cusparseDgebsr2gebsr_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseDgebsr2gebsr_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
long[] pBufferSize) |
static int |
JCusparse.cusparseDgebsr2gebsr(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC,
int rowBlockDimC,
int colBlockDimC,
Pointer pBuffer) |
static int |
JCusparse.cusparseDgemvi_bufferSize(cusparseHandle handle,
int transA,
int m,
int n,
int nnz,
Pointer pBufferSize) |
static int |
JCusparse.cusparseDgemvi(cusparseHandle handle,
int transA,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer beta,
Pointer y,
int idxBase,
Pointer pBuffer) |
static int |
JCusparse.cusparseDgthr(cusparseHandle handle,
int nnz,
Pointer y,
Pointer xVal,
Pointer xInd,
int idxBase) |
static int |
JCusparse.cusparseDgthrz(cusparseHandle handle,
int nnz,
Pointer y,
Pointer xVal,
Pointer xInd,
int idxBase) |
static int |
JCusparse.cusparseDgtsv_nopivot(cusparseHandle handle,
int m,
int n,
Pointer dl,
Pointer d,
Pointer du,
Pointer B,
int ldb) |
static int |
JCusparse.cusparseDgtsv(cusparseHandle handle,
int m,
int n,
Pointer dl,
Pointer d,
Pointer du,
Pointer B,
int ldb) |
static int |
JCusparse.cusparseDgtsvStridedBatch(cusparseHandle handle,
int m,
Pointer dl,
Pointer d,
Pointer du,
Pointer x,
int batchCount,
int batchStride) |
static int |
JCusparse.cusparseDhyb2csc(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer cscSortedVal,
Pointer cscSortedRowInd,
Pointer cscSortedColPtr) |
static int |
JCusparse.cusparseDhyb2csr(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA) |
static int |
JCusparse.cusparseDhyb2dense(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer A,
int lda) |
static int |
JCusparse.cusparseDhybmv(cusparseHandle handle,
int transA,
Pointer alpha,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseDhybsv_solve(cusparseHandle handle,
int trans,
Pointer alpha,
cusparseMatDescr descra,
cusparseHybMat hybA,
cusparseSolveAnalysisInfo info,
Pointer f,
Pointer x) |
static int |
JCusparse.cusparseDnnz(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRowCol,
Pointer nnzTotalDevHostPtr) |
static int |
JCusparse.cusparseDroti(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
Pointer c,
Pointer s,
int idxBase) |
static int |
JCusparse.cusparseDsctr(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
int idxBase) |
static int |
JCusparse.cusparseGetLevelInfo(cusparseHandle handle,
cusparseSolveAnalysisInfo info,
int[] nlevels,
Pointer levelPtr,
Pointer levelInd) |
static int |
JCusparse.cusparseSaxpyi(cusparseHandle handle,
int nnz,
Pointer alpha,
Pointer xVal,
Pointer xInd,
Pointer y,
int idxBase)
Description: Addition of a scalar multiple of a sparse vector x
and a dense vector y.
|
static int |
JCusparse.cusparseSbsr2csr(cusparseHandle handle,
int dirA,
int mb,
int nb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC)
Description: This routine converts a sparse matrix in block-CSR storage format
to a sparse matrix in CSR storage format.
|
static int |
JCusparse.cusparseSbsric02_analysis(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
int policy,
Pointer pInputBuffer) |
static int |
JCusparse.cusparseSbsric02_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseSbsric02_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsric02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseSbsric02(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseSbsrilu02_analysis(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseSbsrilu02_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseSbsrilu02_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrilu02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseSbsrilu02_numericBoost(cusparseHandle handle,
bsrilu02Info info,
int enable_boost,
Pointer tol,
Pointer boost_val)
Description: Compute the incomplete-LU factorization with 0 fill-in (ILU0)
of the matrix A stored in block-CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (bsrsv2_analysis).
|
static int |
JCusparse.cusparseSbsrilu02(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descra,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseSbsrmm(cusparseHandle handle,
int dirA,
int transA,
int transB,
int mb,
int n,
int kb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockSize,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc)
Description: sparse - dense matrix multiplication C = alpha * op(A) * B + beta * C,
where A is a sparse matrix in block-CSR format, B and C are dense tall matrices.
|
static int |
JCusparse.cusparseSbsrmv(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
Pointer x,
Pointer beta,
Pointer y)
Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y,
where A is a sparse matrix in BSR storage format, x and y are dense vectors.
|
static int |
JCusparse.cusparseSbsrsm2_analysis(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseSbsrsm2_bufferSize(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseSbsrsm2_bufferSizeExt(cusparseHandle handle,
int dirA,
int transA,
int transB,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseSbsrsm2_solve(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
Pointer F,
int ldf,
Pointer X,
int ldx,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseSbsrsv2_analysis(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseSbsrsv2_bufferSize(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseSbsrsv2_bufferSizeExt(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockSize,
bsrsv2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseSbsrsv2_solve(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
Pointer f,
Pointer x,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseSbsrxmv(cusparseHandle handle,
int dirA,
int transA,
int sizeOfMask,
int mb,
int nb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedMaskPtrA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedEndPtrA,
Pointer bsrSortedColIndA,
int blockDim,
Pointer x,
Pointer beta,
Pointer y)
Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y,
where A is a sparse matrix in extended BSR storage format, x and y are dense
vectors.
|
static int |
JCusparse.cusparseScsc2dense(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA,
Pointer A,
int lda)
Description: This routine converts a sparse matrix in CSC storage format
to a dense matrix.
|
static int |
JCusparse.cusparseScsc2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA,
cusparseHybMat hybA,
int userEllWidth,
int partitionType)
Description: This routine converts a sparse matrix in CSC storage format
to a sparse matrix in HYB storage format.
|
static int |
JCusparse.cusparseScsr2bsr(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int blockDim,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC) |
static int |
JCusparse.cusparseScsr2csc(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
Pointer cscSortedVal,
Pointer cscSortedRowInd,
Pointer cscSortedColPtr,
int copyValues,
int idxBase)
Description: This routine converts a matrix from CSR to CSC sparse
storage format.
|
static int |
JCusparse.cusparseScsr2csru(cusparseHandle handle,
int m,
int n,
int nnz,
cusparseMatDescr descrA,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
Pointer pBuffer)
Description: Wrapper that un-sorts sparse matrix stored in CSR format
(without exposing the permutation).
|
static int |
JCusparse.cusparseScsr2dense(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer A,
int lda)
Description: This routine converts a sparse matrix in CSR storage format
to a dense matrix.
|
static int |
JCusparse.cusparseScsr2gebsr_bufferSize(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
Pointer pBufferSizeInBytes)
Description: This routine converts a sparse matrix in CSR storage format
to a sparse matrix in general block-CSR storage format.
|
static int |
JCusparse.cusparseScsr2gebsr_bufferSizeExt(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
long[] pBufferSize) |
static int |
JCusparse.cusparseScsr2gebsr(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC,
int rowBlockDim,
int colBlockDim,
Pointer pBuffer) |
static int |
JCusparse.cusparseScsr2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseHybMat hybA,
int userEllWidth,
int partitionType)
Description: This routine converts a sparse matrix in CSR storage format
to a sparse matrix in HYB storage format.
|
static int |
JCusparse.cusparseScsrcolor(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer fractionToColor,
Pointer ncolors,
Pointer coloring,
Pointer reordering,
cusparseColorInfo info)
Description: Find an approximate coloring of a matrix stored in CSR format.
|
static int |
JCusparse.cusparseScsrgeam(cusparseHandle handle,
int m,
int n,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer beta,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseScsrgemm(cusparseHandle handle,
int transA,
int transB,
int m,
int n,
int k,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseScsrgemm2_bufferSizeExt(cusparseHandle handle,
int m,
int n,
int k,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
Pointer beta,
cusparseMatDescr descrD,
int nnzD,
Pointer csrSortedRowPtrD,
Pointer csrSortedColIndD,
csrgemm2Info info,
long[] pBufferSizeInBytes) |
static int |
JCusparse.cusparseScsrgemm2(cusparseHandle handle,
int m,
int n,
int k,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
Pointer beta,
cusparseMatDescr descrD,
int nnzD,
Pointer csrSortedValD,
Pointer csrSortedRowPtrD,
Pointer csrSortedColIndD,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC,
csrgemm2Info info,
Pointer pBuffer) |
static int |
JCusparse.cusparseScsric0(cusparseHandle handle,
int trans,
int m,
cusparseMatDescr descrA,
Pointer csrSortedValA_ValM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info)
Description: Compute the incomplete-Cholesky factorization with 0 fill-in (IC0)
of the matrix A stored in CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (csrsv_analysis).
|
static int |
JCusparse.cusparseScsric02_analysis(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseScsric02_bufferSize(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseScsric02_bufferSizeExt(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
csric02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseScsric02(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA_valM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseScsrilu0(cusparseHandle handle,
int trans,
int m,
cusparseMatDescr descrA,
Pointer csrSortedValA_ValM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info)
Description: Compute the incomplete-LU factorization with 0 fill-in (ILU0)
of the matrix A stored in CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (csrsv_analysis).
|
static int |
JCusparse.cusparseScsrilu02_analysis(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseScsrilu02_bufferSize(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseScsrilu02_bufferSizeExt(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
csrilu02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseScsrilu02_numericBoost(cusparseHandle handle,
csrilu02Info info,
int enable_boost,
Pointer tol,
Pointer boost_val)
Description: Compute the incomplete-LU factorization with 0 fill-in (ILU0)
of the matrix A stored in CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (csrsv2_analysis).
|
static int |
JCusparse.cusparseScsrilu02(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA_valM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseScsrmm(cusparseHandle handle,
int transA,
int m,
int n,
int k,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc)
Description: sparse - dense matrix multiplication C = alpha * op(A) * B + beta * C,
where A is a sparse matrix in CSR format, B and C are dense tall matrices.
|
static int |
JCusparse.cusparseScsrmm2(cusparseHandle handle,
int transA,
int transB,
int m,
int n,
int k,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc)
Description: sparse - dense matrix multiplication C = alpha * op(A) * B + beta * C,
where A is a sparse matrix in CSR format, B and C are dense tall matrices.
|
static int |
JCusparse.cusparseScsrmv(cusparseHandle handle,
int transA,
int m,
int n,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer x,
Pointer beta,
Pointer y)
Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y,
where A is a sparse matrix in CSR storage format, x and y are dense vectors.
|
static int |
JCusparse.cusparseScsrsm_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info)
Description: Solution of triangular linear system op(A) * X = alpha * F,
with multiple right-hand-sides, where A is a sparse matrix in CSR storage
format, rhs F and solution X are dense tall matrices.
|
static int |
JCusparse.cusparseScsrsm_solve(cusparseHandle handle,
int transA,
int m,
int n,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info,
Pointer F,
int ldf,
Pointer X,
int ldx) |
static int |
JCusparse.cusparseScsrsv_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info)
Description: Solution of triangular linear system op(A) * x = alpha * f,
where A is a sparse matrix in CSR storage format, rhs f and solution x
are dense vectors.
|
static int |
JCusparse.cusparseScsrsv_solve(cusparseHandle handle,
int transA,
int m,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info,
Pointer f,
Pointer x) |
static int |
JCusparse.cusparseScsrsv2_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseScsrsv2_bufferSize(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseScsrsv2_bufferSizeExt(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseScsrsv2_solve(cusparseHandle handle,
int transA,
int m,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
Pointer f,
Pointer x,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseScsru2csr_bufferSizeExt(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
long[] pBufferSizeInBytes)
Description: Wrapper that sorts sparse matrix stored in CSR format
(without exposing the permutation).
|
static int |
JCusparse.cusparseScsru2csr(cusparseHandle handle,
int m,
int n,
int nnz,
cusparseMatDescr descrA,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
Pointer pBuffer) |
static int |
JCusparse.cusparseSdense2csc(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerCol,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA)
Description: This routine converts a dense matrix to a sparse matrix
in the CSC storage format, using the information computed by the
nnz routine.
|
static int |
JCusparse.cusparseSdense2csr(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRow,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA)
Description: This routine converts a dense matrix to a sparse matrix
in the CSR storage format, using the information computed by the
nnz routine.
|
static int |
JCusparse.cusparseSdense2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRow,
cusparseHybMat hybA,
int userEllWidth,
int partitionType)
Description: This routine converts a dense matrix to a sparse matrix
in HYB storage format.
|
static int |
JCusparse.cusparseSdoti(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
Pointer resultDevHostPtr,
int idxBase)
Description: dot product of a sparse vector x and a dense vector y.
|
static int |
JCusparse.cusparseSgebsr2csr(cusparseHandle handle,
int dirA,
int mb,
int nb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDim,
int colBlockDim,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseSgebsr2gebsc_bufferSize(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
Pointer pBufferSizeInBytes)
Description: This routine converts a sparse matrix in general block-CSR storage format
to a sparse matrix in general block-CSC storage format.
|
static int |
JCusparse.cusparseSgebsr2gebsc_bufferSizeExt(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
long[] pBufferSize) |
static int |
JCusparse.cusparseSgebsr2gebsc(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
Pointer bscVal,
Pointer bscRowInd,
Pointer bscColPtr,
int copyValues,
int baseIdx,
Pointer pBuffer) |
static int |
JCusparse.cusparseSgebsr2gebsr_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
Pointer pBufferSizeInBytes)
Description: This routine converts a sparse matrix in general block-CSR storage format
to a sparse matrix in general block-CSR storage format with different block size.
|
static int |
JCusparse.cusparseSgebsr2gebsr_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
long[] pBufferSize) |
static int |
JCusparse.cusparseSgebsr2gebsr(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC,
int rowBlockDimC,
int colBlockDimC,
Pointer pBuffer) |
static int |
JCusparse.cusparseSgemvi_bufferSize(cusparseHandle handle,
int transA,
int m,
int n,
int nnz,
Pointer pBufferSize) |
static int |
JCusparse.cusparseSgemvi(cusparseHandle handle,
int transA,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer beta,
Pointer y,
int idxBase,
Pointer pBuffer)
--- Sparse Level 2 routines ---
|
static int |
JCusparse.cusparseSgthr(cusparseHandle handle,
int nnz,
Pointer y,
Pointer xVal,
Pointer xInd,
int idxBase)
Description: Gather of non-zero elements from dense vector y into
sparse vector x.
|
static int |
JCusparse.cusparseSgthrz(cusparseHandle handle,
int nnz,
Pointer y,
Pointer xVal,
Pointer xInd,
int idxBase)
Description: Gather of non-zero elements from desne vector y into
sparse vector x (also replacing these elements in y by zeros).
|
static int |
JCusparse.cusparseSgtsv_nopivot(cusparseHandle handle,
int m,
int n,
Pointer dl,
Pointer d,
Pointer du,
Pointer B,
int ldb)
Description: Solution of tridiagonal linear system A * X = F,
with multiple right-hand-sides.
|
static int |
JCusparse.cusparseSgtsv(cusparseHandle handle,
int m,
int n,
Pointer dl,
Pointer d,
Pointer du,
Pointer B,
int ldb)
Description: Solution of tridiagonal linear system A * X = F,
with multiple right-hand-sides.
|
static int |
JCusparse.cusparseSgtsvStridedBatch(cusparseHandle handle,
int m,
Pointer dl,
Pointer d,
Pointer du,
Pointer x,
int batchCount,
int batchStride)
Description: Solution of a set of tridiagonal linear systems
A_{i} * x_{i} = f_{i} for i=1,...,batchCount.
|
static int |
JCusparse.cusparseShyb2csc(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer cscSortedVal,
Pointer cscSortedRowInd,
Pointer cscSortedColPtr)
Description: This routine converts a sparse matrix in HYB storage format
to a sparse matrix in CSC storage format.
|
static int |
JCusparse.cusparseShyb2csr(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA)
Description: This routine converts a sparse matrix in HYB storage format
to a sparse matrix in CSR storage format.
|
static int |
JCusparse.cusparseShyb2dense(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer A,
int lda)
Description: This routine converts a sparse matrix in HYB storage format
to a dense matrix.
|
static int |
JCusparse.cusparseShybmv(cusparseHandle handle,
int transA,
Pointer alpha,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer x,
Pointer beta,
Pointer y)
Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y,
where A is a sparse matrix in HYB storage format, x and y are dense vectors.
|
static int |
JCusparse.cusparseShybsv_solve(cusparseHandle handle,
int trans,
Pointer alpha,
cusparseMatDescr descra,
cusparseHybMat hybA,
cusparseSolveAnalysisInfo info,
Pointer f,
Pointer x) |
static int |
JCusparse.cusparseSnnz(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRowCol,
Pointer nnzTotalDevHostPtr)
Description: This routine finds the total number of non-zero elements and
the number of non-zero elements per row or column in the dense matrix A.
|
static int |
JCusparse.cusparseSroti(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
Pointer c,
Pointer s,
int idxBase)
Description: Givens rotation, where c and s are cosine and sine,
x and y are sparse and dense vectors, respectively.
|
static int |
JCusparse.cusparseSsctr(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
int idxBase)
Description: Scatter of elements of the sparse vector x into
dense vector y.
|
static int |
JCusparse.cusparseXbsric02_zeroPivot(cusparseHandle handle,
bsric02Info info,
Pointer position)
Description: Compute the incomplete-Cholesky factorization with 0 fill-in (IC0)
of the matrix A stored in block-CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (bsrsv2_analysis).
|
static int |
JCusparse.cusparseXbsrilu02_zeroPivot(cusparseHandle handle,
bsrilu02Info info,
Pointer position) |
static int |
JCusparse.cusparseXbsrsm2_zeroPivot(cusparseHandle handle,
bsrsm2Info info,
Pointer position)
Description: Solution of triangular linear system op(A) * X = alpha * F,
with multiple right-hand-sides, where A is a sparse matrix in CSR storage
format, rhs F and solution X are dense tall matrices.
|
static int |
JCusparse.cusparseXbsrsv2_zeroPivot(cusparseHandle handle,
bsrsv2Info info,
Pointer position)
Description: Solution of triangular linear system op(A) * x = alpha * f,
where A is a sparse matrix in block-CSR storage format, rhs f and solution y
are dense vectors.
|
static int |
JCusparse.cusparseXcoo2csr(cusparseHandle handle,
Pointer cooRowInd,
int nnz,
int m,
Pointer csrSortedRowPtr,
int idxBase)
Description: This routine compresses the indecis of rows or columns.
|
static int |
JCusparse.cusparseXcoosort_bufferSizeExt(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer cooRowsA,
Pointer cooColsA,
long[] pBufferSizeInBytes)
Description: Sort sparse matrix stored in COO format
|
static int |
JCusparse.cusparseXcoosortByColumn(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer cooRowsA,
Pointer cooColsA,
Pointer P,
Pointer pBuffer) |
static int |
JCusparse.cusparseXcoosortByRow(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer cooRowsA,
Pointer cooColsA,
Pointer P,
Pointer pBuffer) |
static int |
JCusparse.cusparseXcscsort_bufferSizeExt(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer cscColPtrA,
Pointer cscRowIndA,
long[] pBufferSizeInBytes)
Description: Sort sparse matrix stored in CSC format
|
static int |
JCusparse.cusparseXcscsort(cusparseHandle handle,
int m,
int n,
int nnz,
cusparseMatDescr descrA,
Pointer cscColPtrA,
Pointer cscRowIndA,
Pointer P,
Pointer pBuffer) |
static int |
JCusparse.cusparseXcsr2bsrNnz(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int blockDim,
cusparseMatDescr descrC,
Pointer bsrSortedRowPtrC,
Pointer nnzTotalDevHostPtr)
Description: This routine converts a sparse matrix in CSR storage format
to a sparse matrix in block-CSR storage format.
|
static int |
JCusparse.cusparseXcsr2coo(cusparseHandle handle,
Pointer csrSortedRowPtr,
int nnz,
int m,
Pointer cooRowInd,
int idxBase)
Description: This routine uncompresses the indecis of rows or columns.
|
static int |
JCusparse.cusparseXcsr2gebsrNnz(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrC,
Pointer bsrSortedRowPtrC,
int rowBlockDim,
int colBlockDim,
Pointer nnzTotalDevHostPtr,
Pointer pBuffer) |
static int |
JCusparse.cusparseXcsrgeamNnz(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
cusparseMatDescr descrC,
Pointer csrSortedRowPtrC,
Pointer nnzTotalDevHostPtr)
Description: Compute sparse - sparse matrix addition of matrices
stored in CSR format
|
static int |
JCusparse.cusparseXcsrgemm2Nnz(cusparseHandle handle,
int m,
int n,
int k,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
cusparseMatDescr descrD,
int nnzD,
Pointer csrSortedRowPtrD,
Pointer csrSortedColIndD,
cusparseMatDescr descrC,
Pointer csrSortedRowPtrC,
Pointer nnzTotalDevHostPtr,
csrgemm2Info info,
Pointer pBuffer) |
static int |
JCusparse.cusparseXcsrgemmNnz(cusparseHandle handle,
int transA,
int transB,
int m,
int n,
int k,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
cusparseMatDescr descrC,
Pointer csrSortedRowPtrC,
Pointer nnzTotalDevHostPtr)
Description: Compute sparse - sparse matrix multiplication for matrices
stored in CSR format.
|
static int |
JCusparse.cusparseXcsric02_zeroPivot(cusparseHandle handle,
csric02Info info,
Pointer position)
Description: Compute the incomplete-Cholesky factorization with 0 fill-in (IC0)
of the matrix A stored in CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (csrsv2_analysis).
|
static int |
JCusparse.cusparseXcsrilu02_zeroPivot(cusparseHandle handle,
csrilu02Info info,
Pointer position) |
static int |
JCusparse.cusparseXcsrsort_bufferSizeExt(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer csrRowPtrA,
Pointer csrColIndA,
long[] pBufferSizeInBytes)
Description: Sort sparse matrix stored in CSR format
|
static int |
JCusparse.cusparseXcsrsort(cusparseHandle handle,
int m,
int n,
int nnz,
cusparseMatDescr descrA,
Pointer csrRowPtrA,
Pointer csrColIndA,
Pointer P,
Pointer pBuffer) |
static int |
JCusparse.cusparseXcsrsv2_zeroPivot(cusparseHandle handle,
csrsv2Info info,
Pointer position)
Description: Solution of triangular linear system op(A) * x = alpha * f,
where A is a sparse matrix in CSR storage format, rhs f and solution y
are dense vectors.
|
static int |
JCusparse.cusparseXgebsr2csr(cusparseHandle handle,
int dirA,
int mb,
int nb,
cusparseMatDescr descrA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDim,
int colBlockDim,
cusparseMatDescr descrC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC)
Description: This routine converts a sparse matrix in general block-CSR storage format
to a sparse matrix in CSR storage format.
|
static int |
JCusparse.cusparseXgebsr2gebsrNnz(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
cusparseMatDescr descrC,
Pointer bsrSortedRowPtrC,
int rowBlockDimC,
int colBlockDimC,
Pointer nnzTotalDevHostPtr,
Pointer pBuffer) |
static int |
JCusparse.cusparseZaxpyi(cusparseHandle handle,
int nnz,
Pointer alpha,
Pointer xVal,
Pointer xInd,
Pointer y,
int idxBase) |
static int |
JCusparse.cusparseZbsr2csr(cusparseHandle handle,
int dirA,
int mb,
int nb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseZbsric02_analysis(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
int policy,
Pointer pInputBuffer) |
static int |
JCusparse.cusparseZbsric02_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseZbsric02_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsric02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseZbsric02(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZbsrilu02_analysis(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZbsrilu02_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseZbsrilu02_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrilu02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseZbsrilu02_numericBoost(cusparseHandle handle,
bsrilu02Info info,
int enable_boost,
Pointer tol,
Pointer boost_val) |
static int |
JCusparse.cusparseZbsrilu02(cusparseHandle handle,
int dirA,
int mb,
int nnzb,
cusparseMatDescr descra,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockDim,
bsrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZbsrmm(cusparseHandle handle,
int dirA,
int transA,
int transB,
int mb,
int n,
int kb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockSize,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCusparse.cusparseZbsrmv(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseZbsrsm2_analysis(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZbsrsm2_bufferSize(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseZbsrsm2_bufferSizeExt(cusparseHandle handle,
int dirA,
int transA,
int transB,
int mb,
int n,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseZbsrsm2_solve(cusparseHandle handle,
int dirA,
int transA,
int transXY,
int mb,
int n,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int blockSize,
bsrsm2Info info,
Pointer F,
int ldf,
Pointer X,
int ldx,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZbsrsv2_analysis(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZbsrsv2_bufferSize(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseZbsrsv2_bufferSizeExt(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockSize,
bsrsv2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseZbsrsv2_solve(cusparseHandle handle,
int dirA,
int transA,
int mb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int blockDim,
bsrsv2Info info,
Pointer f,
Pointer x,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZbsrxmv(cusparseHandle handle,
int dirA,
int transA,
int sizeOfMask,
int mb,
int nb,
int nnzb,
Pointer alpha,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedMaskPtrA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedEndPtrA,
Pointer bsrSortedColIndA,
int blockDim,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseZcsc2dense(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA,
Pointer A,
int lda) |
static int |
JCusparse.cusparseZcsc2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA,
cusparseHybMat hybA,
int userEllWidth,
int partitionType) |
static int |
JCusparse.cusparseZcsr2bsr(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int blockDim,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC) |
static int |
JCusparse.cusparseZcsr2csc(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
Pointer cscSortedVal,
Pointer cscSortedRowInd,
Pointer cscSortedColPtr,
int copyValues,
int idxBase) |
static int |
JCusparse.cusparseZcsr2csru(cusparseHandle handle,
int m,
int n,
int nnz,
cusparseMatDescr descrA,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
Pointer pBuffer) |
static int |
JCusparse.cusparseZcsr2dense(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer A,
int lda) |
static int |
JCusparse.cusparseZcsr2gebsr_bufferSize(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseZcsr2gebsr_bufferSizeExt(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
long[] pBufferSize) |
static int |
JCusparse.cusparseZcsr2gebsr(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC,
int rowBlockDim,
int colBlockDim,
Pointer pBuffer) |
static int |
JCusparse.cusparseZcsr2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseHybMat hybA,
int userEllWidth,
int partitionType) |
static int |
JCusparse.cusparseZcsrcolor(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer fractionToColor,
Pointer ncolors,
Pointer coloring,
Pointer reordering,
cusparseColorInfo info) |
static int |
JCusparse.cusparseZcsrgeam(cusparseHandle handle,
int m,
int n,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer beta,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseZcsrgemm(cusparseHandle handle,
int transA,
int transB,
int m,
int n,
int k,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseZcsrgemm2_bufferSizeExt(cusparseHandle handle,
int m,
int n,
int k,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
Pointer beta,
cusparseMatDescr descrD,
int nnzD,
Pointer csrSortedRowPtrD,
Pointer csrSortedColIndD,
csrgemm2Info info,
long[] pBufferSizeInBytes) |
static int |
JCusparse.cusparseZcsrgemm2(cusparseHandle handle,
int m,
int n,
int k,
Pointer alpha,
cusparseMatDescr descrA,
int nnzA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseMatDescr descrB,
int nnzB,
Pointer csrSortedValB,
Pointer csrSortedRowPtrB,
Pointer csrSortedColIndB,
Pointer beta,
cusparseMatDescr descrD,
int nnzD,
Pointer csrSortedValD,
Pointer csrSortedRowPtrD,
Pointer csrSortedColIndD,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC,
csrgemm2Info info,
Pointer pBuffer) |
static int |
JCusparse.cusparseZcsric0(cusparseHandle handle,
int trans,
int m,
cusparseMatDescr descrA,
Pointer csrSortedValA_ValM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseZcsric02_analysis(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZcsric02_bufferSize(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseZcsric02_bufferSizeExt(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
csric02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseZcsric02(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA_valM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csric02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZcsrilu0(cusparseHandle handle,
int trans,
int m,
cusparseMatDescr descrA,
Pointer csrSortedValA_ValM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseZcsrilu02_analysis(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZcsrilu02_bufferSize(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseZcsrilu02_bufferSizeExt(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedVal,
Pointer csrSortedRowPtr,
Pointer csrSortedColInd,
csrilu02Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseZcsrilu02_numericBoost(cusparseHandle handle,
csrilu02Info info,
int enable_boost,
Pointer tol,
Pointer boost_val) |
static int |
JCusparse.cusparseZcsrilu02(cusparseHandle handle,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA_valM,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrilu02Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZcsrmm(cusparseHandle handle,
int transA,
int m,
int n,
int k,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCusparse.cusparseZcsrmm2(cusparseHandle handle,
int transA,
int transB,
int m,
int n,
int k,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer B,
int ldb,
Pointer beta,
Pointer C,
int ldc) |
static int |
JCusparse.cusparseZcsrmv(cusparseHandle handle,
int transA,
int m,
int n,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseZcsrsm_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseZcsrsm_solve(cusparseHandle handle,
int transA,
int m,
int n,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info,
Pointer F,
int ldf,
Pointer X,
int ldx) |
static int |
JCusparse.cusparseZcsrsv_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info) |
static int |
JCusparse.cusparseZcsrsv_solve(cusparseHandle handle,
int transA,
int m,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
cusparseSolveAnalysisInfo info,
Pointer f,
Pointer x) |
static int |
JCusparse.cusparseZcsrsv2_analysis(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZcsrsv2_bufferSize(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseZcsrsv2_bufferSizeExt(cusparseHandle handle,
int transA,
int m,
int nnz,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
long[] pBufferSize) |
static int |
JCusparse.cusparseZcsrsv2_solve(cusparseHandle handle,
int transA,
int m,
int nnz,
Pointer alpha,
cusparseMatDescr descrA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA,
csrsv2Info info,
Pointer f,
Pointer x,
int policy,
Pointer pBuffer) |
static int |
JCusparse.cusparseZcsru2csr_bufferSizeExt(cusparseHandle handle,
int m,
int n,
int nnz,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
long[] pBufferSizeInBytes) |
static int |
JCusparse.cusparseZcsru2csr(cusparseHandle handle,
int m,
int n,
int nnz,
cusparseMatDescr descrA,
Pointer csrVal,
Pointer csrRowPtr,
Pointer csrColInd,
csru2csrInfo info,
Pointer pBuffer) |
static int |
JCusparse.cusparseZdense2csc(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerCol,
Pointer cscSortedValA,
Pointer cscSortedRowIndA,
Pointer cscSortedColPtrA) |
static int |
JCusparse.cusparseZdense2csr(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRow,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA) |
static int |
JCusparse.cusparseZdense2hyb(cusparseHandle handle,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRow,
cusparseHybMat hybA,
int userEllWidth,
int partitionType) |
static int |
JCusparse.cusparseZdotci(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
Pointer resultDevHostPtr,
int idxBase) |
static int |
JCusparse.cusparseZdoti(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
Pointer resultDevHostPtr,
int idxBase) |
static int |
JCusparse.cusparseZgebsr2csr(cusparseHandle handle,
int dirA,
int mb,
int nb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDim,
int colBlockDim,
cusparseMatDescr descrC,
Pointer csrSortedValC,
Pointer csrSortedRowPtrC,
Pointer csrSortedColIndC) |
static int |
JCusparse.cusparseZgebsr2gebsc_bufferSize(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseZgebsr2gebsc_bufferSizeExt(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
long[] pBufferSize) |
static int |
JCusparse.cusparseZgebsr2gebsc(cusparseHandle handle,
int mb,
int nb,
int nnzb,
Pointer bsrSortedVal,
Pointer bsrSortedRowPtr,
Pointer bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
Pointer bscVal,
Pointer bscRowInd,
Pointer bscColPtr,
int copyValues,
int baseIdx,
Pointer pBuffer) |
static int |
JCusparse.cusparseZgebsr2gebsr_bufferSize(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
Pointer pBufferSizeInBytes) |
static int |
JCusparse.cusparseZgebsr2gebsr_bufferSizeExt(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
long[] pBufferSize) |
static int |
JCusparse.cusparseZgebsr2gebsr(cusparseHandle handle,
int dirA,
int mb,
int nb,
int nnzb,
cusparseMatDescr descrA,
Pointer bsrSortedValA,
Pointer bsrSortedRowPtrA,
Pointer bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
cusparseMatDescr descrC,
Pointer bsrSortedValC,
Pointer bsrSortedRowPtrC,
Pointer bsrSortedColIndC,
int rowBlockDimC,
int colBlockDimC,
Pointer pBuffer) |
static int |
JCusparse.cusparseZgemvi_bufferSize(cusparseHandle handle,
int transA,
int m,
int n,
int nnz,
Pointer pBufferSize) |
static int |
JCusparse.cusparseZgemvi(cusparseHandle handle,
int transA,
int m,
int n,
Pointer alpha,
Pointer A,
int lda,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer beta,
Pointer y,
int idxBase,
Pointer pBuffer) |
static int |
JCusparse.cusparseZgthr(cusparseHandle handle,
int nnz,
Pointer y,
Pointer xVal,
Pointer xInd,
int idxBase) |
static int |
JCusparse.cusparseZgthrz(cusparseHandle handle,
int nnz,
Pointer y,
Pointer xVal,
Pointer xInd,
int idxBase) |
static int |
JCusparse.cusparseZgtsv_nopivot(cusparseHandle handle,
int m,
int n,
Pointer dl,
Pointer d,
Pointer du,
Pointer B,
int ldb) |
static int |
JCusparse.cusparseZgtsv(cusparseHandle handle,
int m,
int n,
Pointer dl,
Pointer d,
Pointer du,
Pointer B,
int ldb) |
static int |
JCusparse.cusparseZgtsvStridedBatch(cusparseHandle handle,
int m,
Pointer dl,
Pointer d,
Pointer du,
Pointer x,
int batchCount,
int batchStride) |
static int |
JCusparse.cusparseZhyb2csc(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer cscSortedVal,
Pointer cscSortedRowInd,
Pointer cscSortedColPtr) |
static int |
JCusparse.cusparseZhyb2csr(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer csrSortedValA,
Pointer csrSortedRowPtrA,
Pointer csrSortedColIndA) |
static int |
JCusparse.cusparseZhyb2dense(cusparseHandle handle,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer A,
int lda) |
static int |
JCusparse.cusparseZhybmv(cusparseHandle handle,
int transA,
Pointer alpha,
cusparseMatDescr descrA,
cusparseHybMat hybA,
Pointer x,
Pointer beta,
Pointer y) |
static int |
JCusparse.cusparseZhybsv_solve(cusparseHandle handle,
int trans,
Pointer alpha,
cusparseMatDescr descra,
cusparseHybMat hybA,
cusparseSolveAnalysisInfo info,
Pointer f,
Pointer x) |
static int |
JCusparse.cusparseZnnz(cusparseHandle handle,
int dirA,
int m,
int n,
cusparseMatDescr descrA,
Pointer A,
int lda,
Pointer nnzPerRowCol,
Pointer nnzTotalDevHostPtr) |
static int |
JCusparse.cusparseZsctr(cusparseHandle handle,
int nnz,
Pointer xVal,
Pointer xInd,
Pointer y,
int idxBase) |
| Modifier and Type | Field and Description |
|---|---|
Pointer |
cudaPointerAttributes.devicePointer
The address which may be dereferenced on the current device to access
the memory or NULL if no such address exists.
|
Pointer |
cudaPointerAttributes.hostPointer
The address which may be dereferenced on the host to access the
memory or NULL if no such address exists.
|
Pointer |
cudaResourceDesc.linear_devPtr
Device pointer for
cudaResourceType.cudaResourceTypeLinear |
Pointer |
cudaResourceDesc.pitch2D_devPtr
Device pointer for
cudaResourceType.cudaResourceTypePitch2D |
Pointer |
cudaPitchedPtr.ptr
Pointer to allocated memory.
|
| Modifier and Type | Method and Description |
|---|---|
static int |
JCuda.cudaBindTexture(long[] offset,
textureReference texref,
Pointer devPtr,
cudaChannelFormatDesc desc,
long size)
[C++ API] Binds a memory area to a texture
|
static int |
JCuda.cudaBindTexture2D(long[] offset,
textureReference texref,
Pointer devPtr,
cudaChannelFormatDesc desc,
long width,
long height,
long pitch)
[C++ API] Binds a 2D memory area to a texture
|
static int |
JCuda.cudaFree(Pointer devPtr)
Frees memory on the device.
|
static int |
JCuda.cudaFreeHost(Pointer ptr)
Frees page-locked memory.
|
static int |
JCuda.cudaGetSymbolAddress(Pointer devPtr,
String symbol)
[C++ API] Finds the address associated with a CUDA symbol
|
static int |
JCuda.cudaGLMapBufferObject(Pointer devPtr,
int bufObj)
Deprecated.
Deprecated as of CUDA 3.0
|
static int |
JCuda.cudaGLMapBufferObjectAsync(Pointer devPtr,
int bufObj,
cudaStream_t stream)
Deprecated.
Deprecated as of CUDA 3.0
|
static int |
JCuda.cudaGraphicsResourceGetMappedPointer(Pointer devPtr,
long[] size,
cudaGraphicsResource resource)
Get an device pointer through which to access a mapped graphics resource.
|
static int |
JCuda.cudaHostAlloc(Pointer ptr,
long size,
int flags)
Allocates page-locked memory on the host.
|
static int |
JCuda.cudaHostGetDevicePointer(Pointer pDevice,
Pointer pHost,
int flags)
Passes back device pointer of mapped host memory allocated by cudaHostAlloc or registered by cudaHostRegister.
|
static int |
JCuda.cudaHostRegister(Pointer ptr,
long size,
int flags)
Registers an existing host memory range for use by CUDA.
|
static int |
JCuda.cudaHostUnregister(Pointer ptr)
Unregisters a memory range that was registered with cudaHostRegister.
|
static int |
JCuda.cudaIpcCloseMemHandle(Pointer devPtr)
Close memory mapped with cudaIpcOpenMemHandle.
|
static int |
JCuda.cudaIpcGetMemHandle(cudaIpcMemHandle handle,
Pointer devPtr)
cudaError_t cudaIpcGetMemHandle (
cudaIpcMemHandle_t* handle,
void* devPtr )
|
static int |
JCuda.cudaIpcOpenMemHandle(Pointer devPtr,
cudaIpcMemHandle handle,
int flags)
cudaError_t cudaIpcOpenMemHandle (
void** devPtr,
cudaIpcMemHandle_t handle,
unsigned int flags )
|
static int |
JCuda.cudaMalloc(Pointer devPtr,
long size)
Allocate memory on the device.
|
static int |
JCuda.cudaMallocHost(Pointer ptr,
long size)
[C++ API] Allocates page-locked memory on the host
|
static int |
JCuda.cudaMallocManaged(Pointer devPtr,
long size,
int flags) |
static int |
JCuda.cudaMallocPitch(Pointer devPtr,
long[] pitch,
long width,
long height)
Allocates pitched memory on the device.
|
static int |
JCuda.cudaMemcpy(Pointer dst,
Pointer src,
long count,
int cudaMemcpyKind_kind)
Copies data between host and device.
|
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)
Copies data between host and device.
|
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)
Copies data between host and device.
|
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)
Copies data between host and device.
|
static int |
JCuda.cudaMemcpyAsync(Pointer dst,
Pointer src,
long count,
int cudaMemcpyKind_kind,
cudaStream_t stream)
Copies data between host and device.
|
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)
Copies data between host and device.
|
static int |
JCuda.cudaMemcpyFromSymbol(Pointer dst,
String symbol,
long count,
long offset,
int cudaMemcpyKind_kind)
[C++ API] Copies data from the given symbol on the device
|
static int |
JCuda.cudaMemcpyFromSymbolAsync(Pointer dst,
String symbol,
long count,
long offset,
int cudaMemcpyKind_kind,
cudaStream_t stream)
[C++ API] Copies data from the given symbol on the device
|
static int |
JCuda.cudaMemcpyPeer(Pointer dst,
int dstDevice,
Pointer src,
int srcDevice,
long count)
Copies memory between two devices.
|
static int |
JCuda.cudaMemcpyPeerAsync(Pointer dst,
int dstDevice,
Pointer src,
int srcDevice,
long count,
cudaStream_t stream)
Copies memory between two devices asynchronously.
|
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)
Copies data between host and device.
|
static int |
JCuda.cudaMemcpyToSymbol(String symbol,
Pointer src,
long count,
long offset,
int cudaMemcpyKind_kind)
[C++ API] Copies data to the given symbol on the device
|
static int |
JCuda.cudaMemcpyToSymbolAsync(String symbol,
Pointer src,
long count,
long offset,
int cudaMemcpyKind_kind,
cudaStream_t stream)
[C++ API] Copies data to the given symbol on the device
|
static int |
JCuda.cudaMemset(Pointer mem,
int c,
long count)
Initializes or sets device memory to a value.
|
static int |
JCuda.cudaMemset2D(Pointer mem,
long pitch,
int c,
long width,
long height)
Initializes or sets device memory to a value.
|
static int |
JCuda.cudaMemset2DAsync(Pointer devPtr,
long pitch,
int value,
long width,
long height,
cudaStream_t stream)
Initializes or sets device memory to a value.
|
static int |
JCuda.cudaMemsetAsync(Pointer devPtr,
int value,
long count,
cudaStream_t stream)
Initializes or sets device memory to a value.
|
static int |
JCuda.cudaPointerGetAttributes(cudaPointerAttributes attributes,
Pointer ptr)
Returns attributes about a specified pointer.
|
static int |
JCuda.cudaSetupArgument(Pointer arg,
long size,
long offset)
Deprecated.
This function is deprecated as of CUDA 7.0
|
static int |
JCuda.cudaStreamAttachMemAsync(cudaStream_t stream,
Pointer devPtr,
long length,
int flags) |
| Modifier and Type | Method and Description |
|---|---|
Pointer |
CublasPointer.getDevicePointer() |
| Modifier and Type | Method and Description |
|---|---|
Pointer |
JCudaBuffer.getDevicePointer(INDArray arr,
int stride,
int offset,
int length)
Get the device pointer with the given offset and stride
|
Pointer |
BaseCudaDataBuffer.getDevicePointer(INDArray arr,
int stride,
int offset,
int length) |
Pointer |
JCudaBuffer.getDevicePointer(int stride,
int offset,
int length)
Get the device pointer with the given offset and stride
|
Pointer |
BaseCudaDataBuffer.getDevicePointer(int stride,
int offset,
int length) |
Pointer |
JCudaBuffer.getHostPointer()
THe pointer for the buffer
|
Pointer |
BaseCudaDataBuffer.getHostPointer() |
Pointer |
JCudaBuffer.getHostPointer(int offset)
Get the host pointer with the given offset
note that this will automatically
multiply the specified offset
by the element size
|
Pointer |
BaseCudaDataBuffer.getHostPointer(int offset) |
Pointer |
DevicePointerInfo.getPointer() |
| Modifier and Type | Method and Description |
|---|---|
protected void |
BaseCudaDataBuffer.set(int index,
int length,
Pointer from)
Set an individual element
|
protected void |
BaseCudaDataBuffer.set(int index,
int length,
Pointer from,
int inc)
Set an individual element
|
protected void |
BaseCudaDataBuffer.set(int index,
Pointer from)
Set an individual element
|
void |
JCudaBuffer.set(Pointer pointer)
Sets the data for this pointer
from the data in this pointer
|
void |
BaseCudaDataBuffer.set(Pointer pointer) |
| Constructor and Description |
|---|
DevicePointerInfo(Pointer pointer,
long length,
int stride,
int offset) |
| Modifier and Type | Method and Description |
|---|---|
static Pointer |
PointerUtil.getPointer(cuComplex x)
Get the pointer for a single complex float
|
static Pointer |
PointerUtil.getPointer(cuDoubleComplex x)
Get the pointer for a single complex float
|
static Pointer |
PointerUtil.getPointer(double alpha) |
static Pointer |
PointerUtil.getPointer(float alpha) |
static Pointer |
PointerUtil.getPointer(IComplexDouble x)
Get the pointer for a single complex float
|
static Pointer |
PointerUtil.getPointer(IComplexFloat x)
Get the pointer for a single complex float
|
Copyright © 2015. All Rights Reserved.