jcuda.vec

Class VecDouble

java.lang.Object

jcuda.vec.VecDouble

public class VecDouble
extends Object

Vector operations for double-precision floating point vectors.

Before any of the vector methods of this class can be called, it has to be initialized by calling init(). In order to release all resources allocated by this class, shutdown() has to be called.
NOTE: This class only forms a thin layer around the actual CUDA kernel calls. It can not verify the function parameters. The caller is responsible for giving appropriate pointers and vector sizes.

Method Summary

Modifier and Type	Method and Description
static void	acos(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the arc cosine of the input argument.
static void	acosh(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the nonnegative arc hyperbolic cosine of the input argument.
static void	add(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Add the given vectors.
static void	addScalar(long n, jcuda.Pointer result, jcuda.Pointer x, double y) Add the given scalar to the given vector.
static void	asin(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the arc sine of the input argument.
static void	asinh(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the arc hyperbolic sine of the input argument.
static void	atan(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the arc tangent of the input argument.
static void	atanh(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the arc hyperbolic tangent of the input argument.
static void	cbrt(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the cube root of the input argument.
static void	ceil(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate ceiling of the input argument.
static void	copysign(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Create value with given magnitude, copying sign of second value.
static void	cos(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the cosine of the input argument.
static void	cosh(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the hyperbolic cosine of the input argument.
static void	cospi(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the cosine of the input argument times pi
static void	div(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Divide the given vectors.
static void	divScalar(long n, jcuda.Pointer result, jcuda.Pointer x, double y) Divide the given vector by the given scalar.
static void	eq(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Perform a '==' comparison of the given vectors.
static void	eqScalar(long n, jcuda.Pointer result, jcuda.Pointer x, double y) Perform a '==' comparison of the given vector and scalar.
static void	erf(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the error function of the input argument.
static void	erfc(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the complementary error function of the input argument.
static void	erfcinv(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the inverse complementary error function of the input argument.
static void	erfcx(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the scaled complementary error function of the input argument.
static void	erfinv(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the inverse error function of the input argument.
static void	exp(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the base e exponential of the input argument.
static void	exp10(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the base 10 exponential of the input argument.
static void	exp2(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the base 2 exponential of the input argument.
static void	expm1(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the base e exponential of the input argument, minus 1.
static void	fabs(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the absolute value of its argument.
static void	fdim(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Compute the positive difference between x and y.
static void	fdivide(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Divide two floating point values.
static void	floor(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the largest integer less than or equal to x.
static void	fmax(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Determine the maximum numeric value of the arguments.
static void	fmin(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Determine the minimum numeric value of the arguments.
static void	fmod(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Calculate the floating-point remainder of x / y.
static void	gt(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Perform a '>' comparison of the given vectors.
static void	gte(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Perform a '>=' comparison of the given vectors.
static void	gteScalar(long n, jcuda.Pointer result, jcuda.Pointer x, double y) Perform a '>=' comparison of the given vector and scalar.
static void	gtScalar(long n, jcuda.Pointer result, jcuda.Pointer x, double y) Perform a '>' comparison of the given vector and scalar.
static void	hypot(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Calculate the square root of the sum of squares of two arguments.
static void	init() Initialize this class.
static void	j0(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the value of the Bessel function of the first kind of order 0 for the input argument.
static void	j1(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the value of the Bessel function of the first kind of order 1 for the input argument.
static void	lgamma(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the natural logarithm of the absolute value of the gamma function of the input argument.
static void	log(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the natural logarithm of the input argument.
static void	log10(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the base 10 logarithm of the input argument.
static void	log1p(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the value of l o g e ( 1 + x ) .
static void	log2(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the base 2 logarithm of the input argument.
static void	logb(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the floating point representation of the exponent of the input argument.
static void	lt(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Perform a '<' comparison of the given vectors.
static void	lte(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Perform a '<=' comparison of the given vectors.
static void	lteScalar(long n, jcuda.Pointer result, jcuda.Pointer x, double y) Perform a '<=' comparison of the given vector and scalar.
static void	ltScalar(long n, jcuda.Pointer result, jcuda.Pointer x, double y) Perform a '<' comparison of the given vector and scalar.
static void	mul(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Multiply the given vectors.
static void	mulScalar(long n, jcuda.Pointer result, jcuda.Pointer x, double y) Multiply the given vector with the given scalar.
static void	ne(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Perform a '!
static void	negate(long n, jcuda.Pointer result, jcuda.Pointer x) Negate the given vector.
static void	neScalar(long n, jcuda.Pointer result, jcuda.Pointer x, double y) Perform a '!
static void	nextafter(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Return next representable single-precision floating-point value after argument.
static void	normcdf(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the standard normal cumulative distribution function.
static void	normcdfinv(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the inverse of the standard normal cumulative distribution function.
static void	pow(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Calculate the value of first argument to the power of second argument.
static void	rcbrt(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate reciprocal cube root function.
static void	remainder(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Compute single-precision floating-point remainder.
static void	rint(long n, jcuda.Pointer result, jcuda.Pointer x) Round input to nearest integer value in floating-point.
static void	round(long n, jcuda.Pointer result, jcuda.Pointer x) Round to nearest integer value in floating-point.
static void	rsqrt(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the reciprocal of the square root of the input argument.
static void	scalarAdd(long n, jcuda.Pointer result, double x, jcuda.Pointer y) Add the given vector to the given scalar.
static void	scalarDiv(long n, jcuda.Pointer result, double x, jcuda.Pointer y) Divide the given scalar by the given vector.
static void	scalarMul(long n, jcuda.Pointer result, double x, jcuda.Pointer y) Multiply the given scalar with the given vector.
static void	scalarSub(long n, jcuda.Pointer result, double x, jcuda.Pointer y) Subtract the given vector from the given scalar.
static void	set(long n, jcuda.Pointer result, double value) Set all elements of the given vector to the given value
static void	shutdown() Perform a shutdown and release all resources allocated by this class.
static void	sin(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the sine of the input argument.
static void	sinh(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the hyperbolic sine of the input argument.
static void	sinpi(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the sine of the input argument times pi
static void	sqrt(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the square root of the input argument.
static void	sub(long n, jcuda.Pointer result, jcuda.Pointer x, jcuda.Pointer y) Subtract the given vectors.
static void	subScalar(long n, jcuda.Pointer result, jcuda.Pointer x, double y) Subtract the given scalar from the given vector.
static void	tan(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the tangent of the input argument.
static void	tanh(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the hyperbolic tangent of the input argument.
static void	tgamma(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the gamma function of the input argument.
static void	trunc(long n, jcuda.Pointer result, jcuda.Pointer x) Truncate input argument to the integral part.
static void	y0(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the value of the Bessel function of the second kind of order 0 for the input argument.
static void	y1(long n, jcuda.Pointer result, jcuda.Pointer x) Calculate the value of the Bessel function of the second kind of order 1 for the input argument.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

init

public static void init()

Initialize this class. This method has to be called before any of the vector operation methods of this class can be called. The resources that are allocated by this call may be freed by calling shutdown().

Throws:

jcuda.CudaException - If the class can not be initialized. Reasons for this may be (but are not limited to) :

• It is neither possible to attach to an existing context, nor to create a new context.
• The resource that contains the kernels (for example, a PTX file) can not be loaded

shutdown

public static void shutdown()

Perform a shutdown and release all resources allocated by this class.

set

public static void set(long n,
                       jcuda.Pointer result,
                       double value)

Set all elements of the given vector to the given value

Parameters:

n - The size of the vector

result - The vector that will store the result

value - The value to set

add

public static void add(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x,
                       jcuda.Pointer y)

Add the given vectors.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

sub

public static void sub(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x,
                       jcuda.Pointer y)

Subtract the given vectors.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

mul

public static void mul(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x,
                       jcuda.Pointer y)

Multiply the given vectors.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

div

public static void div(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x,
                       jcuda.Pointer y)

Divide the given vectors.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

negate

public static void negate(long n,
                          jcuda.Pointer result,
                          jcuda.Pointer x)

Negate the given vector.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

addScalar

public static void addScalar(long n,
                             jcuda.Pointer result,
                             jcuda.Pointer x,
                             double y)

Add the given scalar to the given vector.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The scalar

subScalar

public static void subScalar(long n,
                             jcuda.Pointer result,
                             jcuda.Pointer x,
                             double y)

Subtract the given scalar from the given vector.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The scalar

mulScalar

public static void mulScalar(long n,
                             jcuda.Pointer result,
                             jcuda.Pointer x,
                             double y)

Multiply the given vector with the given scalar.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The scalar

divScalar

public static void divScalar(long n,
                             jcuda.Pointer result,
                             jcuda.Pointer x,
                             double y)

Divide the given vector by the given scalar.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The scalar

scalarAdd

public static void scalarAdd(long n,
                             jcuda.Pointer result,
                             double x,
                             jcuda.Pointer y)

Add the given vector to the given scalar.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The scalar

y - The vector

scalarSub

public static void scalarSub(long n,
                             jcuda.Pointer result,
                             double x,
                             jcuda.Pointer y)

Subtract the given vector from the given scalar.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The scalar

y - The vector

scalarMul

public static void scalarMul(long n,
                             jcuda.Pointer result,
                             double x,
                             jcuda.Pointer y)

Multiply the given scalar with the given vector.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The scalar

y - The vector

scalarDiv

public static void scalarDiv(long n,
                             jcuda.Pointer result,
                             double x,
                             jcuda.Pointer y)

Divide the given scalar by the given vector.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The scalar

y - The vector

lt

public static void lt(long n,
                      jcuda.Pointer result,
                      jcuda.Pointer x,
                      jcuda.Pointer y)

Perform a '<' comparison of the given vectors. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The second vector

lte

public static void lte(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x,
                       jcuda.Pointer y)

Perform a '<=' comparison of the given vectors. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The second vector

eq

public static void eq(long n,
                      jcuda.Pointer result,
                      jcuda.Pointer x,
                      jcuda.Pointer y)

Perform a '==' comparison of the given vectors. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The second vector

gte

public static void gte(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x,
                       jcuda.Pointer y)

Perform a '>=' comparison of the given vectors. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The second vector

gt

public static void gt(long n,
                      jcuda.Pointer result,
                      jcuda.Pointer x,
                      jcuda.Pointer y)

Perform a '>' comparison of the given vectors. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The second vector

ne

public static void ne(long n,
                      jcuda.Pointer result,
                      jcuda.Pointer x,
                      jcuda.Pointer y)

Perform a '!=' comparison of the given vectors. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The second vector

ltScalar

public static void ltScalar(long n,
                            jcuda.Pointer result,
                            jcuda.Pointer x,
                            double y)

Perform a '<' comparison of the given vector and scalar. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The scalar

lteScalar

public static void lteScalar(long n,
                             jcuda.Pointer result,
                             jcuda.Pointer x,
                             double y)

Perform a '<=' comparison of the given vector and scalar. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The scalar

eqScalar

public static void eqScalar(long n,
                            jcuda.Pointer result,
                            jcuda.Pointer x,
                            double y)

Perform a '==' comparison of the given vector and scalar. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The scalar

gteScalar

public static void gteScalar(long n,
                             jcuda.Pointer result,
                             jcuda.Pointer x,
                             double y)

Perform a '>=' comparison of the given vector and scalar. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The scalar

gtScalar

public static void gtScalar(long n,
                            jcuda.Pointer result,
                            jcuda.Pointer x,
                            double y)

Perform a '>' comparison of the given vector and scalar. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The scalar

neScalar

public static void neScalar(long n,
                            jcuda.Pointer result,
                            jcuda.Pointer x,
                            double y)

Perform a '!=' comparison of the given vector and scalar. The result will be set to 1.0f where the comparison yields true, and to 0.0f where the comparison yields false.

Parameters:

n - The size of the vectors

result - The vector that will store the result.

x - The first vector

y - The scalar

acos

public static void acos(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the arc cosine of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

acosh

public static void acosh(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the nonnegative arc hyperbolic cosine of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

asin

public static void asin(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the arc sine of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

asinh

public static void asinh(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the arc hyperbolic sine of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

atan

public static void atan(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the arc tangent of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

atanh

public static void atanh(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the arc hyperbolic tangent of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

cbrt

public static void cbrt(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the cube root of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

ceil

public static void ceil(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate ceiling of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

cos

public static void cos(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x)

Calculate the cosine of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

cosh

public static void cosh(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the hyperbolic cosine of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

cospi

public static void cospi(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the cosine of the input argument times pi

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

erfc

public static void erfc(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the complementary error function of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

erfcinv

public static void erfcinv(long n,
                           jcuda.Pointer result,
                           jcuda.Pointer x)

Calculate the inverse complementary error function of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

erfcx

public static void erfcx(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the scaled complementary error function of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

erf

public static void erf(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x)

Calculate the error function of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

erfinv

public static void erfinv(long n,
                          jcuda.Pointer result,
                          jcuda.Pointer x)

Calculate the inverse error function of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

exp10

public static void exp10(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the base 10 exponential of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

exp2

public static void exp2(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the base 2 exponential of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

exp

public static void exp(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x)

Calculate the base e exponential of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

expm1

public static void expm1(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the base e exponential of the input argument, minus 1.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

fabs

public static void fabs(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the absolute value of its argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

floor

public static void floor(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the largest integer less than or equal to x.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

j0

public static void j0(long n,
                      jcuda.Pointer result,
                      jcuda.Pointer x)

Calculate the value of the Bessel function of the first kind of order 0 for the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

j1

public static void j1(long n,
                      jcuda.Pointer result,
                      jcuda.Pointer x)

Calculate the value of the Bessel function of the first kind of order 1 for the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

lgamma

public static void lgamma(long n,
                          jcuda.Pointer result,
                          jcuda.Pointer x)

Calculate the natural logarithm of the absolute value of the gamma function of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

log10

public static void log10(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the base 10 logarithm of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

log1p

public static void log1p(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the value of l o g e ( 1 + x ) .

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

log2

public static void log2(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the base 2 logarithm of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

logb

public static void logb(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the floating point representation of the exponent of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

log

public static void log(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x)

Calculate the natural logarithm of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

normcdf

public static void normcdf(long n,
                           jcuda.Pointer result,
                           jcuda.Pointer x)

Calculate the standard normal cumulative distribution function.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

normcdfinv

public static void normcdfinv(long n,
                              jcuda.Pointer result,
                              jcuda.Pointer x)

Calculate the inverse of the standard normal cumulative distribution function.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

rcbrt

public static void rcbrt(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate reciprocal cube root function.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

rint

public static void rint(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Round input to nearest integer value in floating-point.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

round

public static void round(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Round to nearest integer value in floating-point.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

rsqrt

public static void rsqrt(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the reciprocal of the square root of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

sin

public static void sin(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x)

Calculate the sine of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

sinh

public static void sinh(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the hyperbolic sine of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

sinpi

public static void sinpi(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Calculate the sine of the input argument times pi

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

sqrt

public static void sqrt(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the square root of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

tan

public static void tan(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x)

Calculate the tangent of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

tanh

public static void tanh(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x)

Calculate the hyperbolic tangent of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

tgamma

public static void tgamma(long n,
                          jcuda.Pointer result,
                          jcuda.Pointer x)

Calculate the gamma function of the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

trunc

public static void trunc(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x)

Truncate input argument to the integral part.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y0

public static void y0(long n,
                      jcuda.Pointer result,
                      jcuda.Pointer x)

Calculate the value of the Bessel function of the second kind of order 0 for the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y1

public static void y1(long n,
                      jcuda.Pointer result,
                      jcuda.Pointer x)

Calculate the value of the Bessel function of the second kind of order 1 for the input argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

copysign

public static void copysign(long n,
                            jcuda.Pointer result,
                            jcuda.Pointer x,
                            jcuda.Pointer y)

Create value with given magnitude, copying sign of second value.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

fdim

public static void fdim(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x,
                        jcuda.Pointer y)

Compute the positive difference between x and y.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

fdivide

public static void fdivide(long n,
                           jcuda.Pointer result,
                           jcuda.Pointer x,
                           jcuda.Pointer y)

Divide two floating point values.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

fmax

public static void fmax(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x,
                        jcuda.Pointer y)

Determine the maximum numeric value of the arguments.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

fmin

public static void fmin(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x,
                        jcuda.Pointer y)

Determine the minimum numeric value of the arguments.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

fmod

public static void fmod(long n,
                        jcuda.Pointer result,
                        jcuda.Pointer x,
                        jcuda.Pointer y)

Calculate the floating-point remainder of x / y.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

hypot

public static void hypot(long n,
                         jcuda.Pointer result,
                         jcuda.Pointer x,
                         jcuda.Pointer y)

Calculate the square root of the sum of squares of two arguments.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

nextafter

public static void nextafter(long n,
                             jcuda.Pointer result,
                             jcuda.Pointer x,
                             jcuda.Pointer y)

Return next representable single-precision floating-point value after argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

pow

public static void pow(long n,
                       jcuda.Pointer result,
                       jcuda.Pointer x,
                       jcuda.Pointer y)

Calculate the value of first argument to the power of second argument.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector

remainder

public static void remainder(long n,
                             jcuda.Pointer result,
                             jcuda.Pointer x,
                             jcuda.Pointer y)

Compute single-precision floating-point remainder.

Parameters:

n - The size of the vectors

result - The vector that will store the result

x - The first vector

y - The second vector