VecDouble (JCudaVec API Documentation)

java.lang.Object
- jcuda.vec.VecDouble

```
public class VecDouble
extends java.lang.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

Methods
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 × p .
`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 × p .
`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
equals, 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 × p .
    
    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 × p .
    
    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

Class VecDouble

Method Summary

Methods inherited from class java.lang.Object

Method Detail

init

shutdown

set

add

sub

mul

div

negate

addScalar

subScalar

mulScalar

divScalar

scalarAdd

scalarSub

scalarMul

scalarDiv

lt

lte

eq

gte

gt

ne

ltScalar

lteScalar

eqScalar

gteScalar

gtScalar

neScalar

acos

acosh

asin

asinh

atan

atanh

cbrt

ceil

cos

cosh

cospi

erfc

erfcinv

erfcx

erf

erfinv

exp10

exp2

exp

expm1

fabs

floor

j0

j1

lgamma

log10

log1p

log2

logb

log

normcdf

normcdfinv

rcbrt

rint

round

rsqrt

sin

sinh

sinpi

sqrt

tan

tanh

tgamma

trunc

y0

y1

copysign

fdim