|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
| Uses of cuComplex in jcuda.jcublas |
|---|
| Methods in jcuda.jcublas that return cuComplex | |
|---|---|
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. |
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. |
static cuComplex |
cuComplex.cuConj(cuComplex x)
Returns the complex conjugate of the given complex number. |
| Methods in jcuda.jcublas with parameters of type cuComplex | |
|---|---|
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. x and y are single precision complex vectors. |
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. x and y are single precision complex vectors with n elements. |
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 ... n - 1, where lx = 1 if incx >= 0, else lx = 1 + (1 - n) * incx, and similarly for y using ly and incy. |
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. op(A) is one of op(A) = A , op(A) = transpose(A) or op(A) = conjugate(transpose(A)) Matrices A and B are stored in column major format, and lda and ldb are the leading dimensions of the two-dimensonials arrays that contain A and B, respectively. |
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. |
static float |
cuComplex.cuCabs(cuComplex x)
Returns the absolute value of the given complex number. |
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. |
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. |
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. |
|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||