| Package | Description |
|---|---|
| jcuda |
Contains common classes for all JCuda libraries.
|
| jcuda.jcublas |
Contains the classes of JCublas.
|
| org.nd4j.linalg.jcublas.complex | |
| org.nd4j.linalg.jcublas.util |
| Modifier and Type | Method and Description |
|---|---|
static cuComplex |
cuComplex.cuCadd(cuComplex x,
cuComplex y)
Returns a new complex number that is the sum of the given
complex numbers.
|
static cuComplex |
cuComplex.cuCdiv(cuComplex x,
cuComplex y)
Returns the quotient of the given complex numbers.
Original comment: This implementation guards against intermediate underflow and overflow by scaling. |
static cuComplex |
cuComplex.cuCmplx(float r,
float i)
Creates a new complex number consisting of the given real and
imaginary part.
|
static cuComplex |
cuComplex.cuCmul(cuComplex x,
cuComplex y)
Returns the product of the given complex numbers.
Original comment: This implementation could suffer from intermediate overflow even though the final result would be in range. |
static cuComplex |
cuComplex.cuConj(cuComplex x)
Returns the complex conjugate of the given complex number.
|
| Modifier and Type | Method and Description |
|---|---|
static float |
cuComplex.cuCabs(cuComplex x)
Returns the absolute value of the given complex number.
Original comment: This implementation guards against intermediate underflow and overflow by scaling. |
static cuComplex |
cuComplex.cuCadd(cuComplex x,
cuComplex y)
Returns a new complex number that is the sum of the given
complex numbers.
|
static cuComplex |
cuComplex.cuCdiv(cuComplex x,
cuComplex y)
Returns the quotient of the given complex numbers.
Original comment: This implementation guards against intermediate underflow and overflow by scaling. |
static float |
cuComplex.cuCimag(cuComplex x)
Returns the imaginary part of the given complex number.
|
static cuComplex |
cuComplex.cuCmul(cuComplex x,
cuComplex y)
Returns the product of the given complex numbers.
Original comment: This implementation could suffer from intermediate overflow even though the final result would be in range. |
static cuComplex |
cuComplex.cuConj(cuComplex x)
Returns the complex conjugate of the given complex number.
|
static float |
cuComplex.cuCreal(cuComplex x)
Returns the real part of the given complex number.
|
| Modifier and Type | Method and Description |
|---|---|
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 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.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
JCublas.cublasCaxpy(int n,
cuComplex alpha,
Pointer x,
int incx,
Pointer y,
int incy)
void
cublasCaxpy (int n, cuComplex alpha, const cuComplex *x, int incx,
cuComplex *y, int incy)
multiplies single-complex vector x by single-complex scalar alpha and adds
the result to single-complex vector y; that is, it overwrites single-complex
y with single-complex alpha * x + y.
|
static void |
JCublas.cublasCgbmv(char trans,
int m,
int n,
int kl,
int ku,
cuComplex alpha,
Pointer A,
int lda,
Pointer x,
int incx,
cuComplex beta,
Pointer y,
int incy)
void
cublasCgbmv (char trans, int m, int n, int kl, int ku, cuComplex alpha,
const cuComplex *A, int lda, const cuComplex *x, int incx, cuComplex beta,
cuComplex *y, int incy);
performs one of the matrix-vector operations
y = alpha*op(A)*x + beta*y, op(A)=A or op(A) = transpose(A)
alpha and beta are single precision complex scalars.
|
static void |
JCublas.cublasCgemm(char transa,
char transb,
int m,
int n,
int k,
cuComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
cuComplex beta,
Pointer C,
int ldc)
void cublasCgemm (char transa, char transb, int m, int n, int k,
cuComplex alpha, const cuComplex *A, int lda,
const cuComplex *B, int ldb, cuComplex beta,
cuComplex *C, int ldc)
performs one of the matrix-matrix operations
C = alpha * op(A) * op(B) + beta*C,
where op(X) is one of
op(X) = X or op(X) = transpose or op(X) = conjg(transpose(X))
alpha and beta are single-complex scalars, and A, B and C are matrices
consisting of single-complex elements, with op(A) an m x k matrix, op(B)
a k x n matrix and C an m x n matrix.
|
static void |
JCublas.cublasCgemv(char trans,
int m,
int n,
cuComplex alpha,
Pointer A,
int lda,
Pointer x,
int incx,
cuComplex beta,
Pointer y,
int incy)
cublasCgemv (char trans, int m, int n, cuComplex alpha, const cuComplex *A,
int lda, const cuComplex *x, int incx, cuComplex beta, cuComplex *y,
int incy)
performs one of the matrix-vector operations
y = alpha * op(A) * x + beta * y,
where op(A) is one of
op(A) = A or op(A) = transpose(A) or op(A) = conjugate(transpose(A))
where alpha and beta are single precision scalars, x and y are single
precision vectors, and A is an m x n matrix consisting of single precision
elements.
|
static void |
JCublas.cublasCgerc(int m,
int n,
cuComplex alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda)
cublasCgerc (int m, int n, cuComplex alpha, const cuComplex *x, int incx,
const cuComplex *y, int incy, cuComplex *A, int lda)
performs the symmetric rank 1 operation
A = alpha * x * conjugate(transpose(y)) + A,
where alpha is a single precision complex scalar, x is an m element single
precision complex vector, y is an n element single precision complex vector, and A
is an m by n matrix consisting of single precision complex elements.
|
static void |
JCublas.cublasCgeru(int m,
int n,
cuComplex alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda)
cublasCgeru (int m, int n, cuComplex alpha, const cuComplex *x, int incx,
const cuComplex *y, int incy, cuComplex *A, int lda)
performs the symmetric rank 1 operation
A = alpha * x * transpose(y) + A,
where alpha is a single precision complex scalar, x is an m element single
precision complex vector, y is an n element single precision complex vector, and A
is an m by n matrix consisting of single precision complex elements.
|
static void |
JCublas.cublasChbmv(char uplo,
int n,
int k,
cuComplex alpha,
Pointer A,
int lda,
Pointer x,
int incx,
cuComplex beta,
Pointer y,
int incy)
void
cublasChbmv (char uplo, int n, int k, cuComplex alpha, const cuComplex *A, int lda,
const cuComplex *x, int incx, cuComplex beta, cuComplex *y, int incy)
performs the matrix-vector operation
y := alpha*A*x + beta*y
alpha and beta are single precision complex scalars.
|
static void |
JCublas.cublasChemm(char side,
char uplo,
int m,
int n,
cuComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
cuComplex beta,
Pointer C,
int ldc)
void
cublasChemm (char side, char uplo, int m, int n, cuComplex alpha,
const cuComplex *A, int lda, const cuComplex *B, int ldb,
cuComplex beta, cuComplex *C, int ldc);
performs one of the matrix-matrix operations
C = alpha * A * B + beta * C, or
C = alpha * B * A + beta * C,
where alpha and beta are single precision complex scalars, A is a hermitian matrix
consisting of single precision complex elements and stored in either lower or upper
storage mode, and B and C are m x n matrices consisting of single precision
complex elements.
|
static void |
JCublas.cublasChemv(char uplo,
int n,
cuComplex alpha,
Pointer A,
int lda,
Pointer x,
int incx,
cuComplex beta,
Pointer y,
int incy)
void
cublasChemv (char uplo, int n, cuComplex alpha, const cuComplex *A, int lda,
const cuComplex *x, int incx, cuComplex beta, cuComplex *y, int incy)
performs the matrix-vector operation
y = alpha*A*x + beta*y
Alpha and beta are single precision complex scalars, and x and y are single
precision complex vectors, each with n elements.
|
static void |
JCublas.cublasCher2(char uplo,
int n,
cuComplex alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda)
void cublasCher2 (char uplo, int n, cuComplex alpha, const cuComplex *x, int incx,
const cuComplex *y, int incy, cuComplex *A, int lda)
performs the hermitian rank 2 operation
A = alpha*x*conjugate(transpose(y)) + conjugate(alpha)*y*conjugate(transpose(x)) + A,
where alpha is a single precision complex scalar, x and y are n element single
precision complex vector and A is an n by n hermitian matrix consisting of single
precision complex elements.
|
static void |
JCublas.cublasCher2k(char uplo,
char trans,
int n,
int k,
cuComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
float beta,
Pointer C,
int ldc)
void
cublasCher2k (char uplo, char trans, int n, int k, cuComplex alpha,
const cuComplex *A, int lda, const cuComplex *B, int ldb,
float beta, cuComplex *C, int ldc)
performs one of the hermitian rank 2k operations
C = alpha * A * conjugate(transpose(B))
+ conjugate(alpha) * B * conjugate(transpose(A))
+ beta * C ,
or
C = alpha * conjugate(transpose(A)) * B
+ conjugate(alpha) * conjugate(transpose(B)) * A
+ beta * C.
|
static void |
JCublas.cublasChpr2(char uplo,
int n,
cuComplex alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer AP)
void
cublasChpr2 (char uplo, int n, cuComplex alpha, const cuComplex *x, int incx,
const cuComplex *y, int incy, cuComplex *AP)
performs the hermitian rank 2 operation
A = alpha*x*conjugate(transpose(y)) + conjugate(alpha)*y*conjugate(transpose(x)) + A,
where alpha is a single precision complex scalar, and x and y are n element single
precision complex vectors.
|
static void |
JCublas.cublasCrot(int n,
Pointer x,
int incx,
Pointer y,
int incy,
float c,
cuComplex s)
void
cublasCrot (int n, cuComplex *x, int incx, cuComplex *y, int incy, float sc,
cuComplex cs)
multiplies a 2x2 matrix ( sc cs) with the 2xn matrix ( transpose(x) )
(-conj(cs) sc) ( transpose(y) )
The elements of x are in x[lx + i * incx], i = 0 ...
|
static void |
JCublas.cublasCrotg(Pointer host_ca,
cuComplex cb,
Pointer host_sc,
Pointer host_cs)
void
cublasCrotg (cuComplex *host_ca, cuComplex cb, float *host_sc, cuComplex *host_cs)
constructs the complex Givens tranformation
( sc cs )
G = ( ) , sc^2 + cabs(cs)^2 = 1,
(-cs sc )
which zeros the second entry of the complex 2-vector transpose(ca, cb).
|
static void |
JCublas.cublasCscal(int n,
cuComplex alpha,
Pointer x,
int incx)
void
cublasCscal (int n, cuComplex alpha, cuComplex *x, int incx)
replaces single-complex vector x with single-complex alpha * x.
|
static void |
JCublas.cublasCsymm(char side,
char uplo,
int m,
int n,
cuComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
cuComplex beta,
Pointer C,
int ldc)
void
cublasCsymm (char side, char uplo, int m, int n, cuComplex alpha,
const cuComplex *A, int lda, const cuComplex *B, int ldb,
cuComplex beta, cuComplex *C, int ldc);
performs one of the matrix-matrix operations
C = alpha * A * B + beta * C, or
C = alpha * B * A + beta * C,
where alpha and beta are single precision complex scalars, A is a symmetric matrix
consisting of single precision complex elements and stored in either lower or upper
storage mode, and B and C are m x n matrices consisting of single precision
complex elements.
|
static void |
JCublas.cublasCsyr2k(char uplo,
char trans,
int n,
int k,
cuComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
cuComplex beta,
Pointer C,
int ldc)
void
cublasCsyr2k (char uplo, char trans, int n, int k, cuComplex alpha,
const cuComplex *A, int lda, const cuComplex *B, int ldb,
cuComplex beta, cuComplex *C, int ldc)
performs one of the symmetric rank 2k operations
C = alpha * A * transpose(B) + alpha * B * transpose(A) + beta * C, or
C = alpha * transpose(A) * B + alpha * transpose(B) * A + beta * C.
|
static void |
JCublas.cublasCsyrk(char uplo,
char trans,
int n,
int k,
cuComplex alpha,
Pointer A,
int lda,
cuComplex beta,
Pointer C,
int ldc)
void
cublasCsyrk (char uplo, char trans, int n, int k, cuComplex alpha,
const cuComplex *A, int lda, cuComplex beta, cuComplex *C, int ldc)
performs one of the symmetric rank k operations
C = alpha * A * transpose(A) + beta * C, or
C = alpha * transpose(A) * A + beta * C.
|
static void |
JCublas.cublasCtrmm(char side,
char uplo,
char transa,
char diag,
int m,
int n,
cuComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb)
void
cublasCtrmm (char side, char uplo, char transa, char diag, int m, int n,
cuComplex alpha, const cuComplex *A, int lda, const cuComplex *B,
int ldb)
performs one of the matrix-matrix operations
B = alpha * op(A) * B, or B = alpha * B * op(A)
where alpha is a single-precision complex scalar, B is an m x n matrix composed
of single precision complex elements, and A is a unit or non-unit, upper or lower,
triangular matrix composed of single precision complex elements.
|
static void |
JCublas.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 |
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.cublasGetVector(int n,
Pointer x,
int incx,
cuComplex[] y,
int offsety,
int incy)
Extended wrapper for arrays of cuComplex values.
|
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.cublasSetVector(int n,
cuComplex[] x,
int offsetx,
int incx,
Pointer y,
int incy)
Extended wrapper for arrays of cuComplex values.
|
| Modifier and Type | Method and Description |
|---|---|
static cuComplex |
CudaComplexConversion.toComplex(IComplexFloat float1)
Convert a complex float to a cuda complex float
|
| Modifier and Type | Method and Description |
|---|---|
static IComplexFloat |
CudaComplexConversion.toCuFloat(cuComplex cuComplex)
Create a complex float from a cuda float
|
| Modifier and Type | Method and Description |
|---|---|
static Pointer |
PointerUtil.getPointer(cuComplex x)
Get the pointer for a single complex float
|
Copyright © 2015. All Rights Reserved.