|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use cuDoubleComplex | |
|---|---|
| jcuda.jcublas | Contains the classes of JCublas. |
| Uses of cuDoubleComplex in jcuda.jcublas |
|---|
| Methods in jcuda.jcublas that return cuDoubleComplex | |
|---|---|
static cuDoubleComplex |
cuDoubleComplex.cuCadd(cuDoubleComplex x,
cuDoubleComplex y)
Returns a new complex number that is the sum of the given complex numbers. |
static cuDoubleComplex |
cuDoubleComplex.cuCdiv(cuDoubleComplex x,
cuDoubleComplex y)
Returns the quotient of the given complex numbers. Original comment: This implementation guards against intermediate underflow and overflow by scaling. |
static cuDoubleComplex |
cuDoubleComplex.cuCmplx(double r,
double i)
Creates a new complex number consisting of the given real and imaginary part. |
static cuDoubleComplex |
cuDoubleComplex.cuCmul(cuDoubleComplex x,
cuDoubleComplex 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 cuDoubleComplex |
cuDoubleComplex.cuConj(cuDoubleComplex x)
Returns the complex conjugate of the given complex number. |
| Methods in jcuda.jcublas with parameters of type cuDoubleComplex | |
|---|---|
static int |
JCublas.cublasGetMatrix(int rows,
int cols,
Pointer A,
int lda,
cuDoubleComplex[] B,
int offsetB,
int ldb)
Extended wrapper for arrays of cuDoubleComplex values. |
static int |
JCublas.cublasGetVector(int n,
Pointer x,
int incx,
cuDoubleComplex[] y,
int offsety,
int incy)
Extended wrapper for arrays of cuDoubleComplex values. |
static int |
JCublas.cublasSetMatrix(int rows,
int cols,
cuDoubleComplex[] A,
int offsetA,
int lda,
Pointer B,
int ldb)
Extended wrapper for arrays of cuDoubleComplex values. |
static int |
JCublas.cublasSetVector(int n,
cuDoubleComplex[] x,
int offsetx,
int incx,
Pointer y,
int incy)
Extended wrapper for arrays of cuDoubleComplex values. |
static void |
JCublas.cublasZaxpy(int n,
cuDoubleComplex alpha,
Pointer x,
int incx,
Pointer y,
int incy)
void cublasZaxpy (int n, cuDoubleComplex alpha, const cuDoubleComplex *x, int incx, cuDoubleComplex *y, int incy) multiplies double-complex vector x by double-complex scalar alpha and adds the result to double-complex vector y; that is, it overwrites double-complex y with double-complex alpha * x + y. |
static void |
JCublas.cublasZgbmv(char trans,
int m,
int n,
int kl,
int ku,
cuDoubleComplex alpha,
Pointer A,
int lda,
Pointer x,
int incx,
cuDoubleComplex beta,
Pointer y,
int incy)
void cublasZgbmv (char trans, int m, int n, int kl, int ku, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, cuDoubleComplex beta, cuDoubleComplex *y, int incy); performs one of the matrix-vector operations y = alpha*op(A)*x + beta*y, op(A)=A or op(A) = transpose(A) alpha and beta are double precision complex scalars. |
static void |
JCublas.cublasZgemm(char transa,
char transb,
int m,
int n,
int k,
cuDoubleComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
cuDoubleComplex beta,
Pointer C,
int ldc)
void cublasZgemm (char transa, char transb, int m, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, cuDoubleComplex beta, cuDoubleComplex *C, int ldc) zgemm performs one of the matrix-matrix operations C = alpha * op(A) * op(B) + beta*C, where op(X) is one of op(X) = X or op(X) = transpose or op(X) = conjg(transpose(X)) alpha and beta are double-complex scalars, and A, B and C are matrices consisting of double-complex elements, with op(A) an m x k matrix, op(B) a k x n matrix and C an m x n matrix. |
static void |
JCublas.cublasZgemv(char trans,
int m,
int n,
cuDoubleComplex alpha,
Pointer A,
int lda,
Pointer x,
int incx,
cuDoubleComplex beta,
Pointer y,
int incy)
cublasZgemv (char trans, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, cuDoubleComplex beta, cuDoubleComplex *y, int incy) performs one of the matrix-vector operations y = alpha * op(A) * x + beta * y, where op(A) is one of op(A) = A or op(A) = transpose(A) where alpha and beta are double precision scalars, x and y are double precision vectors, and A is an m x n matrix consisting of double precision elements. |
static void |
JCublas.cublasZgerc(int m,
int n,
cuDoubleComplex alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda)
cublasZgerc (int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, int incy, cuDoubleComplex *A, int lda) performs the symmetric rank 1 operation A = alpha * x * conjugate(transpose(y)) + A, where alpha is a double precision complex scalar, x is an m element double precision complex vector, y is an n element double precision complex vector, and A is an m by n matrix consisting of double precision complex elements. |
static void |
JCublas.cublasZgeru(int m,
int n,
cuDoubleComplex alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda)
cublasZgeru (int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, int incy, cuDoubleComplex *A, int lda) performs the symmetric rank 1 operation A = alpha * x * transpose(y) + A, where alpha is a double precision complex scalar, x is an m element double precision complex vector, y is an n element double precision complex vector, and A is an m by n matrix consisting of double precision complex elements. |
static void |
JCublas.cublasZhbmv(char uplo,
int n,
int k,
cuDoubleComplex alpha,
Pointer A,
int lda,
Pointer x,
int incx,
cuDoubleComplex beta,
Pointer y,
int incy)
void cublasZhbmv (char uplo, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, cuDoubleComplex beta, cuDoubleComplex *y, int incy) performs the matrix-vector operation y := alpha*A*x + beta*y alpha and beta are double precision complex scalars. |
static void |
JCublas.cublasZhemm(char side,
char uplo,
int m,
int n,
cuDoubleComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
cuDoubleComplex beta,
Pointer C,
int ldc)
void cublasZhemm (char side, char uplo, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, cuDoubleComplex beta, cuDoubleComplex *C, int ldc); performs one of the matrix-matrix operations C = alpha * A * B + beta * C, or C = alpha * B * A + beta * C, where alpha and beta are double precision complex scalars, A is a hermitian matrix consisting of double precision complex elements and stored in either lower or upper storage mode, and B and C are m x n matrices consisting of double precision complex elements. |
static void |
JCublas.cublasZhemv(char uplo,
int n,
cuDoubleComplex alpha,
Pointer A,
int lda,
Pointer x,
int incx,
cuDoubleComplex beta,
Pointer y,
int incy)
void cublasZhemv (char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *x, int incx, cuDoubleComplex beta, cuDoubleComplex *y, int incy) performs the matrix-vector operation y = alpha*A*x + beta*y Alpha and beta are double precision complex scalars, and x and y are double precision complex vectors, each with n elements. |
static void |
JCublas.cublasZher2(char uplo,
int n,
cuDoubleComplex alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer A,
int lda)
void cublasZher2 (char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, int incy, cuDoubleComplex *A, int lda) performs the hermitian rank 2 operation A = alpha*x*conjugate(transpose(y)) + conjugate(alpha)*y*conjugate(transpose(x)) + A, where alpha is a double precision complex scalar, x and y are n element double precision complex vector and A is an n by n hermitian matrix consisting of double precision complex elements. |
static void |
JCublas.cublasZher2k(char uplo,
char trans,
int n,
int k,
cuDoubleComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
double beta,
Pointer C,
int ldc)
void cublasZher2k (char uplo, char trans, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, double beta, cuDoubleComplex *C, int ldc) performs one of the hermitian rank 2k operations C = alpha * A * conjugate(transpose(B)) + conjugate(alpha) * B * conjugate(transpose(A)) + beta * C , or C = alpha * conjugate(transpose(A)) * B + conjugate(alpha) * conjugate(transpose(B)) * A + beta * C. |
static void |
JCublas.cublasZhpmv(char uplo,
int n,
cuDoubleComplex alpha,
Pointer AP,
Pointer x,
int incx,
cuDoubleComplex beta,
Pointer y,
int incy)
void cublasZhpmv (char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex *AP, const cuDoubleComplex *x, int incx, cuDoubleComplex beta, cuDoubleComplex *y, int incy) performs the matrix-vector operation y = alpha * A * x + beta * y Alpha and beta are double precision complex scalars, and x and y are double precision complex vectors with n elements. |
static void |
JCublas.cublasZhpr2(char uplo,
int n,
cuDoubleComplex alpha,
Pointer x,
int incx,
Pointer y,
int incy,
Pointer AP)
void cublasZhpr2 (char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex *x, int incx, const cuDoubleComplex *y, int incy, cuDoubleComplex *AP) performs the hermitian rank 2 operation A = alpha*x*conjugate(transpose(y)) + conjugate(alpha)*y*conjugate(transpose(x)) + A, where alpha is a double precision complex scalar, and x and y are n element double precision complex vectors. |
static void |
JCublas.cublasZrot(int n,
Pointer x,
int incx,
Pointer y,
int incy,
double sc,
cuDoubleComplex cs)
cublasZrot (int n, cuDoubleComplex *x, int incx, cuDoubleComplex *y, int incy, double sc, cuDoubleComplex cs) multiplies a 2x2 matrix ( sc cs) with the 2xn matrix ( transpose(x) ) (-conj(cs) sc) ( transpose(y) ) The elements of x are in x[lx + i * incx], i = 0 ... |
static void |
JCublas.cublasZrotg(Pointer host_ca,
cuDoubleComplex cb,
Pointer host_sc,
Pointer host_cs)
void cublasZrotg (cuDoubleComplex *host_ca, cuDoubleComplex cb, double *host_sc, double *host_cs) constructs the complex Givens tranformation ( sc cs ) G = ( ) , sc^2 + cabs(cs)^2 = 1, (-cs sc ) which zeros the second entry of the complex 2-vector transpose(ca, cb). |
static void |
JCublas.cublasZscal(int n,
cuDoubleComplex alpha,
Pointer x,
int incx)
void cublasZscal (int n, cuComplex alpha, cuComplex *x, int incx) replaces double-complex vector x with double-complex alpha * x. |
static void |
JCublas.cublasZsymm(char side,
char uplo,
int m,
int n,
cuDoubleComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
cuDoubleComplex beta,
Pointer C,
int ldc)
void cublasZsymm (char side, char uplo, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, cuDoubleComplex beta, cuDoubleComplex *C, int ldc); performs one of the matrix-matrix operations C = alpha * A * B + beta * C, or C = alpha * B * A + beta * C, where alpha and beta are double precision complex scalars, A is a symmetric matrix consisting of double precision complex elements and stored in either lower or upper storage mode, and B and C are m x n matrices consisting of double precision complex elements. |
static void |
JCublas.cublasZsyr2k(char uplo,
char trans,
int n,
int k,
cuDoubleComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb,
cuDoubleComplex beta,
Pointer C,
int ldc)
void cublasZsyr2k (char uplo, char trans, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb, cuDoubleComplex beta, cuDoubleComplex *C, int ldc) performs one of the symmetric rank 2k operations C = alpha * A * transpose(B) + alpha * B * transpose(A) + beta * C, or C = alpha * transpose(A) * B + alpha * transpose(B) * A + beta * C. |
static void |
JCublas.cublasZsyrk(char uplo,
char trans,
int n,
int k,
cuDoubleComplex alpha,
Pointer A,
int lda,
cuDoubleComplex beta,
Pointer C,
int ldc)
void cublasZsyrk (char uplo, char trans, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, cuDoubleComplex beta, cuDoubleComplex *C, int ldc) performs one of the symmetric rank k operations C = alpha * A * transpose(A) + beta * C, or C = alpha * transpose(A) * A + beta * C. |
static void |
JCublas.cublasZtrmm(char side,
char uplo,
char transa,
char diag,
int m,
int n,
cuDoubleComplex alpha,
Pointer A,
int lda,
Pointer B,
int ldb)
void cublasZtrmm (char side, char uplo, char transa, char diag, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex *A, int lda, const cuDoubleComplex *B, int ldb) performs one of the matrix-matrix operations B = alpha * op(A) * B, or B = alpha * B * op(A) where alpha is a double-precision complex scalar, B is an m x n matrix composed of double precision complex elements, and A is a unit or non-unit, upper or lower, triangular matrix composed of double precision complex elements. |
static void |
JCublas.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 double |
cuDoubleComplex.cuCabs(cuDoubleComplex x)
Returns the absolute value of the given complex number. Original comment: This implementation guards against intermediate underflow and overflow by scaling. |
static cuDoubleComplex |
cuDoubleComplex.cuCadd(cuDoubleComplex x,
cuDoubleComplex y)
Returns a new complex number that is the sum of the given complex numbers. |
static cuDoubleComplex |
cuDoubleComplex.cuCdiv(cuDoubleComplex x,
cuDoubleComplex y)
Returns the quotient of the given complex numbers. Original comment: This implementation guards against intermediate underflow and overflow by scaling. |
static double |
cuDoubleComplex.cuCimag(cuDoubleComplex x)
Returns the imaginary part of the given complex number. |
static cuDoubleComplex |
cuDoubleComplex.cuCmul(cuDoubleComplex x,
cuDoubleComplex 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 cuDoubleComplex |
cuDoubleComplex.cuConj(cuDoubleComplex x)
Returns the complex conjugate of the given complex number. |
static double |
cuDoubleComplex.cuCreal(cuDoubleComplex x)
Returns the real part of the given complex number. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||