curand (JavaCPP Presets for CUDA 12.1-8.9-1.5.9 API)

java.lang.Object
- org.bytedeco.cuda.presets.curand
- - org.bytedeco.cuda.global.curand

All Implemented Interfaces:

InfoMapper
```
public class curand
extends curand
```

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CURAND_3RD` enum curandMethod
`static int`	`CURAND_BINARY_SEARCH` enum curandMethod
`static int`	`CURAND_CHOOSE_BEST` enum curandMethod
`static int`	`CURAND_DEFINITION` enum curandMethod
`static int`	`CURAND_DEVICE_API` enum curandMethod
`static int`	`CURAND_DIRECTION_VECTORS_32_JOEKUO6` enum curandDirectionVectorSet
`static int`	`CURAND_DIRECTION_VECTORS_64_JOEKUO6` enum curandDirectionVectorSet
`static int`	`CURAND_DISCRETE_GAUSS` enum curandMethod
`static int`	`CURAND_FAST_REJECTION` enum curandMethod
`static int`	`CURAND_HITR` enum curandMethod
`static int`	`CURAND_ITR` enum curandMethod
`static int`	`CURAND_KNUTH` enum curandMethod
`static int`	`CURAND_M1` enum curandMethod
`static int`	`CURAND_M2` enum curandMethod
`static int`	`CURAND_ORDERING_PSEUDO_BEST` enum curandOrdering
`static int`	`CURAND_ORDERING_PSEUDO_DEFAULT` enum curandOrdering
`static int`	`CURAND_ORDERING_PSEUDO_DYNAMIC` enum curandOrdering
`static int`	`CURAND_ORDERING_PSEUDO_LEGACY` enum curandOrdering
`static int`	`CURAND_ORDERING_PSEUDO_SEEDED` enum curandOrdering
`static int`	`CURAND_ORDERING_QUASI_DEFAULT` enum curandOrdering
`static int`	`CURAND_POISSON` enum curandMethod
`static int`	`CURAND_REJECTION` enum curandMethod
`static int`	`CURAND_RNG_PSEUDO_DEFAULT` enum curandRngType
`static int`	`CURAND_RNG_PSEUDO_MRG32K3A` enum curandRngType
`static int`	`CURAND_RNG_PSEUDO_MT19937` enum curandRngType
`static int`	`CURAND_RNG_PSEUDO_MTGP32` enum curandRngType
`static int`	`CURAND_RNG_PSEUDO_PHILOX4_32_10` enum curandRngType
`static int`	`CURAND_RNG_PSEUDO_XORWOW` enum curandRngType
`static int`	`CURAND_RNG_QUASI_DEFAULT` enum curandRngType
`static int`	`CURAND_RNG_QUASI_SCRAMBLED_SOBOL32` enum curandRngType
`static int`	`CURAND_RNG_QUASI_SCRAMBLED_SOBOL64` enum curandRngType
`static int`	`CURAND_RNG_QUASI_SOBOL32` enum curandRngType
`static int`	`CURAND_RNG_QUASI_SOBOL64` enum curandRngType
`static int`	`CURAND_RNG_TEST` enum curandRngType
`static int`	`CURAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6` enum curandDirectionVectorSet
`static int`	`CURAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6` enum curandDirectionVectorSet
`static int`	`CURAND_STATUS_ALLOCATION_FAILED` enum curandStatus
`static int`	`CURAND_STATUS_ARCH_MISMATCH` enum curandStatus
`static int`	`CURAND_STATUS_DOUBLE_PRECISION_REQUIRED` enum curandStatus
`static int`	`CURAND_STATUS_INITIALIZATION_FAILED` enum curandStatus
`static int`	`CURAND_STATUS_INTERNAL_ERROR` enum curandStatus
`static int`	`CURAND_STATUS_LAUNCH_FAILURE` enum curandStatus
`static int`	`CURAND_STATUS_LENGTH_NOT_MULTIPLE` enum curandStatus
`static int`	`CURAND_STATUS_NOT_INITIALIZED` enum curandStatus
`static int`	`CURAND_STATUS_OUT_OF_RANGE` enum curandStatus
`static int`	`CURAND_STATUS_PREEXISTING_FAILURE` enum curandStatus
`static int`	`CURAND_STATUS_SUCCESS` enum curandStatus
`static int`	`CURAND_STATUS_TYPE_ERROR` enum curandStatus
`static int`	`CURAND_STATUS_VERSION_MISMATCH` enum curandStatus
`static int`	`CURAND_VER_BUILD`
`static int`	`CURAND_VER_MAJOR` \defgroup HOST Host API \{
`static int`	`CURAND_VER_MINOR`
`static int`	`CURAND_VER_PATCH`
`static int`	`CURAND_VERSION`

Constructor Summary

Constructors
Constructor and Description

curand()

Constructors
Constructor and Description
`curand()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static int`	`curandCreateGenerator(curandGenerator_st generator, int rng_type)` \brief Create new random number generator.
`static int`	`curandCreateGeneratorHost(curandGenerator_st generator, int rng_type)` \brief Create new host CPU random number generator.
`static int`	`curandCreatePoissonDistribution(double lambda, curandDiscreteDistribution_st discrete_distribution)` \brief Construct the histogram array for a Poisson distribution.
`static int`	`curandDestroyDistribution(curandDiscreteDistribution_st discrete_distribution)` \brief Destroy the histogram array for a discrete distribution (e.g.
`static int`	`curandDestroyGenerator(curandGenerator_st generator)` \brief Destroy an existing generator.
`static int`	`curandGenerate(curandGenerator_st generator, int[] outputPtr, long num)`
`static int`	`curandGenerate(curandGenerator_st generator, IntBuffer outputPtr, long num)`
`static int`	`curandGenerate(curandGenerator_st generator, IntPointer outputPtr, long num)` \brief Generate 32-bit pseudo or quasirandom numbers.
`static int`	`curandGenerateLogNormal(curandGenerator_st generator, float[] outputPtr, long n, float mean, float stddev)`
`static int`	`curandGenerateLogNormal(curandGenerator_st generator, FloatBuffer outputPtr, long n, float mean, float stddev)`
`static int`	`curandGenerateLogNormal(curandGenerator_st generator, FloatPointer outputPtr, long n, float mean, float stddev)` \brief Generate log-normally distributed floats.
`static int`	`curandGenerateLogNormalDouble(curandGenerator_st generator, double[] outputPtr, long n, double mean, double stddev)`
`static int`	`curandGenerateLogNormalDouble(curandGenerator_st generator, DoubleBuffer outputPtr, long n, double mean, double stddev)`
`static int`	`curandGenerateLogNormalDouble(curandGenerator_st generator, DoublePointer outputPtr, long n, double mean, double stddev)` \brief Generate log-normally distributed doubles.
`static int`	`curandGenerateLongLong(curandGenerator_st generator, long[] outputPtr, long num)`
`static int`	`curandGenerateLongLong(curandGenerator_st generator, LongBuffer outputPtr, long num)`
`static int`	`curandGenerateLongLong(curandGenerator_st generator, LongPointer outputPtr, long num)` \brief Generate 64-bit quasirandom numbers.
`static int`	`curandGenerateNormal(curandGenerator_st generator, float[] outputPtr, long n, float mean, float stddev)`
`static int`	`curandGenerateNormal(curandGenerator_st generator, FloatBuffer outputPtr, long n, float mean, float stddev)`
`static int`	`curandGenerateNormal(curandGenerator_st generator, FloatPointer outputPtr, long n, float mean, float stddev)` \brief Generate normally distributed doubles.
`static int`	`curandGenerateNormalDouble(curandGenerator_st generator, double[] outputPtr, long n, double mean, double stddev)`
`static int`	`curandGenerateNormalDouble(curandGenerator_st generator, DoubleBuffer outputPtr, long n, double mean, double stddev)`
`static int`	`curandGenerateNormalDouble(curandGenerator_st generator, DoublePointer outputPtr, long n, double mean, double stddev)` \brief Generate normally distributed doubles.
`static int`	`curandGeneratePoisson(curandGenerator_st generator, int[] outputPtr, long n, double lambda)`
`static int`	`curandGeneratePoisson(curandGenerator_st generator, IntBuffer outputPtr, long n, double lambda)`
`static int`	`curandGeneratePoisson(curandGenerator_st generator, IntPointer outputPtr, long n, double lambda)` \brief Generate Poisson-distributed unsigned ints.
`static int`	`curandGeneratePoissonMethod(curandGenerator_st generator, int[] outputPtr, long n, double lambda, int method)`
`static int`	`curandGeneratePoissonMethod(curandGenerator_st generator, IntBuffer outputPtr, long n, double lambda, int method)`
`static int`	`curandGeneratePoissonMethod(curandGenerator_st generator, IntPointer outputPtr, long n, double lambda, int method)`
`static int`	`curandGenerateSeeds(curandGenerator_st generator)` \brief Setup starting states.
`static int`	`curandGenerateUniform(curandGenerator_st generator, float[] outputPtr, long num)`
`static int`	`curandGenerateUniform(curandGenerator_st generator, FloatBuffer outputPtr, long num)`
`static int`	`curandGenerateUniform(curandGenerator_st generator, FloatPointer outputPtr, long num)` \brief Generate uniformly distributed floats.
`static int`	`curandGenerateUniformDouble(curandGenerator_st generator, double[] outputPtr, long num)`
`static int`	`curandGenerateUniformDouble(curandGenerator_st generator, DoubleBuffer outputPtr, long num)`
`static int`	`curandGenerateUniformDouble(curandGenerator_st generator, DoublePointer outputPtr, long num)` \brief Generate uniformly distributed doubles.
`static int`	`curandGetDirectionVectors32(int[] vectors, int set)`
`static int`	`curandGetDirectionVectors32(IntBuffer vectors, int set)`
`static int`	`curandGetDirectionVectors32(IntPointer vectors, int set)`
`static int`	`curandGetDirectionVectors32(PointerPointer vectors, int set)` \brief Get direction vectors for 32-bit quasirandom number generation.
`static int`	`curandGetDirectionVectors64(long[] vectors, int set)`
`static int`	`curandGetDirectionVectors64(LongBuffer vectors, int set)`
`static int`	`curandGetDirectionVectors64(LongPointer vectors, int set)`
`static int`	`curandGetDirectionVectors64(PointerPointer vectors, int set)` \brief Get direction vectors for 64-bit quasirandom number generation.
`static int`	`curandGetProperty(int type, int[] value)`
`static int`	`curandGetProperty(int type, IntBuffer value)`
`static int`	`curandGetProperty(int type, IntPointer value)` \brief Return the value of the curand property.
`static int`	`curandGetScrambleConstants32(int[] constants)`
`static int`	`curandGetScrambleConstants32(IntBuffer constants)`
`static int`	`curandGetScrambleConstants32(IntPointer constants)`
`static int`	`curandGetScrambleConstants32(PointerPointer constants)` \brief Get scramble constants for 32-bit scrambled Sobol' .
`static int`	`curandGetScrambleConstants64(long[] constants)`
`static int`	`curandGetScrambleConstants64(LongBuffer constants)`
`static int`	`curandGetScrambleConstants64(LongPointer constants)`
`static int`	`curandGetScrambleConstants64(PointerPointer constants)` \brief Get scramble constants for 64-bit scrambled Sobol' .
`static int`	`curandGetVersion(int[] version)`
`static int`	`curandGetVersion(IntBuffer version)`
`static int`	`curandGetVersion(IntPointer version)` \brief Return the version number of the library.
`static int`	`curandSetGeneratorOffset(curandGenerator_st generator, long offset)` \brief Set the absolute offset of the pseudo or quasirandom number generator.
`static int`	`curandSetGeneratorOrdering(curandGenerator_st generator, int order)` \brief Set the ordering of results of the pseudo or quasirandom number generator.
`static int`	`curandSetPseudoRandomGeneratorSeed(curandGenerator_st generator, long seed)` \brief Set the seed value of the pseudo-random number generator.
`static int`	`curandSetQuasiRandomGeneratorDimensions(curandGenerator_st generator, int num_dimensions)` \brief Set the number of dimensions.
`static int`	`curandSetStream(curandGenerator_st generator, CUstream_st stream)` \brief Set the current stream for CURAND kernel launches.

Methods inherited from class org.bytedeco.cuda.presets.curand
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- CURAND_VER_MAJOR
```
public static final int CURAND_VER_MAJOR
```
  \defgroup HOST Host API \{
  
  See Also:
  
  Constant Field Values
- CURAND_VER_MINOR
```
public static final int CURAND_VER_MINOR
```
  See Also:
  
  Constant Field Values
- CURAND_VER_PATCH
```
public static final int CURAND_VER_PATCH
```
  See Also:
  
  Constant Field Values
- CURAND_VER_BUILD
```
public static final int CURAND_VER_BUILD
```
  See Also:
  
  Constant Field Values
- CURAND_VERSION
```
public static final int CURAND_VERSION
```
  See Also:
  
  Constant Field Values
- CURAND_STATUS_SUCCESS
```
public static final int CURAND_STATUS_SUCCESS
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_VERSION_MISMATCH
```
public static final int CURAND_STATUS_VERSION_MISMATCH
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_NOT_INITIALIZED
```
public static final int CURAND_STATUS_NOT_INITIALIZED
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_ALLOCATION_FAILED
```
public static final int CURAND_STATUS_ALLOCATION_FAILED
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_TYPE_ERROR
```
public static final int CURAND_STATUS_TYPE_ERROR
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_OUT_OF_RANGE
```
public static final int CURAND_STATUS_OUT_OF_RANGE
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_LENGTH_NOT_MULTIPLE
```
public static final int CURAND_STATUS_LENGTH_NOT_MULTIPLE
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_DOUBLE_PRECISION_REQUIRED
```
public static final int CURAND_STATUS_DOUBLE_PRECISION_REQUIRED
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_LAUNCH_FAILURE
```
public static final int CURAND_STATUS_LAUNCH_FAILURE
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_PREEXISTING_FAILURE
```
public static final int CURAND_STATUS_PREEXISTING_FAILURE
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_INITIALIZATION_FAILED
```
public static final int CURAND_STATUS_INITIALIZATION_FAILED
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_ARCH_MISMATCH
```
public static final int CURAND_STATUS_ARCH_MISMATCH
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_STATUS_INTERNAL_ERROR
```
public static final int CURAND_STATUS_INTERNAL_ERROR
```
  enum curandStatus
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_TEST
```
public static final int CURAND_RNG_TEST
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_PSEUDO_DEFAULT
```
public static final int CURAND_RNG_PSEUDO_DEFAULT
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_PSEUDO_XORWOW
```
public static final int CURAND_RNG_PSEUDO_XORWOW
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_PSEUDO_MRG32K3A
```
public static final int CURAND_RNG_PSEUDO_MRG32K3A
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_PSEUDO_MTGP32
```
public static final int CURAND_RNG_PSEUDO_MTGP32
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_PSEUDO_MT19937
```
public static final int CURAND_RNG_PSEUDO_MT19937
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_PSEUDO_PHILOX4_32_10
```
public static final int CURAND_RNG_PSEUDO_PHILOX4_32_10
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_QUASI_DEFAULT
```
public static final int CURAND_RNG_QUASI_DEFAULT
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_QUASI_SOBOL32
```
public static final int CURAND_RNG_QUASI_SOBOL32
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_QUASI_SCRAMBLED_SOBOL32
```
public static final int CURAND_RNG_QUASI_SCRAMBLED_SOBOL32
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_QUASI_SOBOL64
```
public static final int CURAND_RNG_QUASI_SOBOL64
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_RNG_QUASI_SCRAMBLED_SOBOL64
```
public static final int CURAND_RNG_QUASI_SCRAMBLED_SOBOL64
```
  enum curandRngType
  
  See Also:
  
  Constant Field Values
- CURAND_ORDERING_PSEUDO_BEST
```
public static final int CURAND_ORDERING_PSEUDO_BEST
```
  enum curandOrdering
  
  See Also:
  
  Constant Field Values
- CURAND_ORDERING_PSEUDO_DEFAULT
```
public static final int CURAND_ORDERING_PSEUDO_DEFAULT
```
  enum curandOrdering
  
  See Also:
  
  Constant Field Values
- CURAND_ORDERING_PSEUDO_SEEDED
```
public static final int CURAND_ORDERING_PSEUDO_SEEDED
```
  enum curandOrdering
  
  See Also:
  
  Constant Field Values
- CURAND_ORDERING_PSEUDO_LEGACY
```
public static final int CURAND_ORDERING_PSEUDO_LEGACY
```
  enum curandOrdering
  
  See Also:
  
  Constant Field Values
- CURAND_ORDERING_PSEUDO_DYNAMIC
```
public static final int CURAND_ORDERING_PSEUDO_DYNAMIC
```
  enum curandOrdering
  
  See Also:
  
  Constant Field Values
- CURAND_ORDERING_QUASI_DEFAULT
```
public static final int CURAND_ORDERING_QUASI_DEFAULT
```
  enum curandOrdering
  
  See Also:
  
  Constant Field Values
- CURAND_DIRECTION_VECTORS_32_JOEKUO6
```
public static final int CURAND_DIRECTION_VECTORS_32_JOEKUO6
```
  enum curandDirectionVectorSet
  
  See Also:
  
  Constant Field Values
- CURAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6
```
public static final int CURAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6
```
  enum curandDirectionVectorSet
  
  See Also:
  
  Constant Field Values
- CURAND_DIRECTION_VECTORS_64_JOEKUO6
```
public static final int CURAND_DIRECTION_VECTORS_64_JOEKUO6
```
  enum curandDirectionVectorSet
  
  See Also:
  
  Constant Field Values
- CURAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6
```
public static final int CURAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6
```
  enum curandDirectionVectorSet
  
  See Also:
  
  Constant Field Values
- CURAND_CHOOSE_BEST
```
public static final int CURAND_CHOOSE_BEST
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_ITR
```
public static final int CURAND_ITR
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_KNUTH
```
public static final int CURAND_KNUTH
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_HITR
```
public static final int CURAND_HITR
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_M1
```
public static final int CURAND_M1
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_M2
```
public static final int CURAND_M2
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_BINARY_SEARCH
```
public static final int CURAND_BINARY_SEARCH
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_DISCRETE_GAUSS
```
public static final int CURAND_DISCRETE_GAUSS
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_REJECTION
```
public static final int CURAND_REJECTION
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_DEVICE_API
```
public static final int CURAND_DEVICE_API
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_FAST_REJECTION
```
public static final int CURAND_FAST_REJECTION
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_3RD
```
public static final int CURAND_3RD
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_DEFINITION
```
public static final int CURAND_DEFINITION
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values
- CURAND_POISSON
```
public static final int CURAND_POISSON
```
  enum curandMethod
  
  See Also:
  
  Constant Field Values

Constructor Detail
- curand
```
public curand()
```

Method Detail

curandCreateGenerator
```
@Cast(value="curandStatus_t")
public static int curandCreateGenerator(@ByPtrPtr
                                                                      curandGenerator_st generator,
                                                                      @Cast(value="curandRngType_t")
                                                                      int rng_type)
```
\brief Create new random number generator. Creates a new random number generator of type \p rng_type and returns it in \p *generator. Legal values for \p rng_type are: - CURAND_RNG_PSEUDO_DEFAULT - CURAND_RNG_PSEUDO_XORWOW - CURAND_RNG_PSEUDO_MRG32K3A - CURAND_RNG_PSEUDO_MTGP32 - CURAND_RNG_PSEUDO_MT19937 - CURAND_RNG_PSEUDO_PHILOX4_32_10 - CURAND_RNG_QUASI_DEFAULT - CURAND_RNG_QUASI_SOBOL32 - CURAND_RNG_QUASI_SCRAMBLED_SOBOL32 - CURAND_RNG_QUASI_SOBOL64 - CURAND_RNG_QUASI_SCRAMBLED_SOBOL64 When \p rng_type is CURAND_RNG_PSEUDO_DEFAULT, the type chosen is CURAND_RNG_PSEUDO_XORWOW. \n When \p rng_type is CURAND_RNG_QUASI_DEFAULT, the type chosen is CURAND_RNG_QUASI_SOBOL32. The default values for \p rng_type = CURAND_RNG_PSEUDO_XORWOW are: - \p seed = 0 - \p offset = 0 - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT The default values for \p rng_type = CURAND_RNG_PSEUDO_MRG32K3A are: - \p seed = 0 - \p offset = 0 - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT The default values for \p rng_type = CURAND_RNG_PSEUDO_MTGP32 are: - \p seed = 0 - \p offset = 0 - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT The default values for \p rng_type = CURAND_RNG_PSEUDO_MT19937 are: - \p seed = 0 - \p offset = 0 - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT * The default values for \p rng_type = CURAND_RNG_PSEUDO_PHILOX4_32_10 are: - \p seed = 0 - \p offset = 0 - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT The default values for \p rng_type = CURAND_RNG_QUASI_SOBOL32 are: - \p dimensions = 1 - \p offset = 0 - \p ordering = CURAND_ORDERING_QUASI_DEFAULT The default values for \p rng_type = CURAND_RNG_QUASI_SOBOL64 are: - \p dimensions = 1 - \p offset = 0 - \p ordering = CURAND_ORDERING_QUASI_DEFAULT The default values for \p rng_type = CURAND_RNG_QUASI_SCRAMBBLED_SOBOL32 are: - \p dimensions = 1 - \p offset = 0 - \p ordering = CURAND_ORDERING_QUASI_DEFAULT The default values for \p rng_type = CURAND_RNG_QUASI_SCRAMBLED_SOBOL64 are: - \p dimensions = 1 - \p offset = 0 - \p ordering = CURAND_ORDERING_QUASI_DEFAULT

Parameters:

generator - - Pointer to generator

rng_type - - Type of generator to create

Returns:

- CURAND_STATUS_ALLOCATION_FAILED, if memory could not be allocated \n - CURAND_STATUS_INITIALIZATION_FAILED if there was a problem setting up the GPU \n - CURAND_STATUS_VERSION_MISMATCH if the header file version does not match the dynamically linked library version \n - CURAND_STATUS_TYPE_ERROR if the value for \p rng_type is invalid \n - CURAND_STATUS_SUCCESS if generator was created successfully \n

curandCreateGeneratorHost
```
@Cast(value="curandStatus_t")
public static int curandCreateGeneratorHost(@ByPtrPtr
                                                                          curandGenerator_st generator,
                                                                          @Cast(value="curandRngType_t")
                                                                          int rng_type)
```
\brief Create new host CPU random number generator. Creates a new host CPU random number generator of type \p rng_type and returns it in \p *generator. Legal values for \p rng_type are: - CURAND_RNG_PSEUDO_DEFAULT - CURAND_RNG_PSEUDO_XORWOW - CURAND_RNG_PSEUDO_MRG32K3A - CURAND_RNG_PSEUDO_MTGP32 - CURAND_RNG_PSEUDO_MT19937 - CURAND_RNG_PSEUDO_PHILOX4_32_10 - CURAND_RNG_QUASI_DEFAULT - CURAND_RNG_QUASI_SOBOL32 When \p rng_type is CURAND_RNG_PSEUDO_DEFAULT, the type chosen is CURAND_RNG_PSEUDO_XORWOW. \n When \p rng_type is CURAND_RNG_QUASI_DEFAULT, the type chosen is CURAND_RNG_QUASI_SOBOL32. The default values for \p rng_type = CURAND_RNG_PSEUDO_XORWOW are: - \p seed = 0 - \p offset = 0 - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT The default values for \p rng_type = CURAND_RNG_PSEUDO_MRG32K3A are: - \p seed = 0 - \p offset = 0 - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT The default values for \p rng_type = CURAND_RNG_PSEUDO_MTGP32 are: - \p seed = 0 - \p offset = 0 - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT The default values for \p rng_type = CURAND_RNG_PSEUDO_MT19937 are: - \p seed = 0 - \p offset = 0 - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT * The default values for \p rng_type = CURAND_RNG_PSEUDO_PHILOX4_32_10 are: - \p seed = 0 - \p offset = 0 - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT The default values for \p rng_type = CURAND_RNG_QUASI_SOBOL32 are: - \p dimensions = 1 - \p offset = 0 - \p ordering = CURAND_ORDERING_QUASI_DEFAULT The default values for \p rng_type = CURAND_RNG_QUASI_SOBOL64 are: - \p dimensions = 1 - \p offset = 0 - \p ordering = CURAND_ORDERING_QUASI_DEFAULT The default values for \p rng_type = CURAND_RNG_QUASI_SCRAMBLED_SOBOL32 are: - \p dimensions = 1 - \p offset = 0 - \p ordering = CURAND_ORDERING_QUASI_DEFAULT The default values for \p rng_type = CURAND_RNG_QUASI_SCRAMBLED_SOBOL64 are: - \p dimensions = 1 - \p offset = 0 - \p ordering = CURAND_ORDERING_QUASI_DEFAULT

Parameters:

generator - - Pointer to generator

rng_type - - Type of generator to create

Returns:

- CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n - CURAND_STATUS_INITIALIZATION_FAILED if there was a problem setting up the GPU \n - CURAND_STATUS_VERSION_MISMATCH if the header file version does not match the dynamically linked library version \n - CURAND_STATUS_TYPE_ERROR if the value for \p rng_type is invalid \n - CURAND_STATUS_SUCCESS if generator was created successfully \n

curandDestroyGenerator
```
@Cast(value="curandStatus_t")
public static int curandDestroyGenerator(curandGenerator_st generator)
```
\brief Destroy an existing generator. Destroy an existing generator and free all memory associated with its state.

Parameters:

generator - - Generator to destroy

Returns:

- CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_SUCCESS if generator was destroyed successfully \n

curandGetVersion
```
@Cast(value="curandStatus_t")
public static int curandGetVersion(IntPointer version)
```
\brief Return the version number of the library. Return in \p *version the version number of the dynamically linked CURAND library. The format is the same as CUDART_VERSION from the CUDA Runtime. The only supported configuration is CURAND version equal to CUDA Runtime version.

Parameters:

version - - CURAND library version

Returns:

- CURAND_STATUS_SUCCESS if the version number was successfully returned \n

curandGetVersion

@Cast(value="curandStatus_t")
public static int curandGetVersion(IntBuffer version)

curandGetVersion

@Cast(value="curandStatus_t")
public static int curandGetVersion(int[] version)

curandGetProperty
```
@Cast(value="curandStatus_t")
public static int curandGetProperty(@Cast(value="libraryPropertyType")
                                                                  int type,
                                                                  IntPointer value)
```
\brief Return the value of the curand property. Return in \p *value the number for the property described by \p type of the dynamically linked CURAND library.

Parameters:

type - - CUDA library property

value - - integer value for the requested property

Returns:

- CURAND_STATUS_SUCCESS if the property value was successfully returned \n - CURAND_STATUS_OUT_OF_RANGE if the property type is not recognized \n

curandGetProperty

@Cast(value="curandStatus_t")
public static int curandGetProperty(@Cast(value="libraryPropertyType")
                                                                  int type,
                                                                  IntBuffer value)

curandGetProperty

@Cast(value="curandStatus_t")
public static int curandGetProperty(@Cast(value="libraryPropertyType")
                                                                  int type,
                                                                  int[] value)

curandSetStream
```
@Cast(value="curandStatus_t")
public static int curandSetStream(curandGenerator_st generator,
                                                                CUstream_st stream)
```
\brief Set the current stream for CURAND kernel launches. Set the current stream for CURAND kernel launches. All library functions will use this stream until set again.

Parameters:

generator - - Generator to modify

stream - - Stream to use or ::NULL for null stream

Returns:

- CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_SUCCESS if stream was set successfully \n

curandSetPseudoRandomGeneratorSeed
```
@Cast(value="curandStatus_t")
public static int curandSetPseudoRandomGeneratorSeed(curandGenerator_st generator,
                                                                                   @Cast(value="unsigned long long")
                                                                                   long seed)
```
\brief Set the seed value of the pseudo-random number generator. Set the seed value of the pseudorandom number generator. All values of seed are valid. Different seeds will produce different sequences. Different seeds will often not be statistically correlated with each other, but some pairs of seed values may generate sequences which are statistically correlated.

Parameters:

generator - - Generator to modify

seed - - Seed value

Returns:

- CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_TYPE_ERROR if the generator is not a pseudorandom number generator \n - CURAND_STATUS_SUCCESS if generator seed was set successfully \n

curandSetGeneratorOffset
```
@Cast(value="curandStatus_t")
public static int curandSetGeneratorOffset(curandGenerator_st generator,
                                                                         @Cast(value="unsigned long long")
                                                                         long offset)
```
\brief Set the absolute offset of the pseudo or quasirandom number generator. Set the absolute offset of the pseudo or quasirandom number generator. All values of offset are valid. The offset position is absolute, not relative to the current position in the sequence.

Parameters:

generator - - Generator to modify

offset - - Absolute offset position

Returns:

- CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_SUCCESS if generator offset was set successfully \n

curandSetGeneratorOrdering
```
@Cast(value="curandStatus_t")
public static int curandSetGeneratorOrdering(curandGenerator_st generator,
                                                                           @Cast(value="curandOrdering_t")
                                                                           int order)
```
\brief Set the ordering of results of the pseudo or quasirandom number generator. Set the ordering of results of the pseudo or quasirandom number generator. Legal values of \p order for pseudorandom generators are: - CURAND_ORDERING_PSEUDO_DEFAULT - CURAND_ORDERING_PSEUDO_BEST - CURAND_ORDERING_PSEUDO_SEEDED - CURAND_ORDERING_PSEUDO_LEGACY Legal values of \p order for quasirandom generators are: - CURAND_ORDERING_QUASI_DEFAULT

Parameters:

generator - - Generator to modify

order - - Ordering of results

Returns:

- CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_OUT_OF_RANGE if the ordering is not valid \n - CURAND_STATUS_SUCCESS if generator ordering was set successfully \n

curandSetQuasiRandomGeneratorDimensions
```
@Cast(value="curandStatus_t")
public static int curandSetQuasiRandomGeneratorDimensions(curandGenerator_st generator,
                                                                                        @Cast(value="unsigned int")
                                                                                        int num_dimensions)
```
\brief Set the number of dimensions. Set the number of dimensions to be generated by the quasirandom number generator. Legal values for \p num_dimensions are 1 to 20000.

Parameters:

generator - - Generator to modify

num_dimensions - - Number of dimensions

Returns:

- CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_OUT_OF_RANGE if num_dimensions is not valid \n - CURAND_STATUS_TYPE_ERROR if the generator is not a quasirandom number generator \n - CURAND_STATUS_SUCCESS if generator ordering was set successfully \n

curandGenerate
```
@Cast(value="curandStatus_t")
public static int curandGenerate(curandGenerator_st generator,
                                                               @Cast(value="unsigned int*")
                                                               IntPointer outputPtr,
                                                               @Cast(value="size_t")
                                                               long num)
```
\brief Generate 32-bit pseudo or quasirandom numbers. Use \p generator to generate \p num 32-bit results into the device memory at \p outputPtr. The device memory must have been previously allocated and be large enough to hold all the results. Launches are done with the stream set using ::curandSetStream(), or the null stream if no stream has been set. Results are 32-bit values with every bit random.

Parameters:

generator - - Generator to use

outputPtr - - Pointer to device memory to store CUDA-generated results, or Pointer to host memory to store CPU-generated results

num - - Number of random 32-bit values to generate

Returns:

- CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch \n - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension \n - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n - CURAND_STATUS_TYPE_ERROR if the generator is a 64 bit quasirandom generator. (use ::curandGenerateLongLong() with 64 bit quasirandom generators) - CURAND_STATUS_SUCCESS if the results were generated successfully \n

curandGenerate

@Cast(value="curandStatus_t")
public static int curandGenerate(curandGenerator_st generator,
                                                               @Cast(value="unsigned int*")
                                                               IntBuffer outputPtr,
                                                               @Cast(value="size_t")
                                                               long num)

curandGenerate

@Cast(value="curandStatus_t")
public static int curandGenerate(curandGenerator_st generator,
                                                               @Cast(value="unsigned int*")
                                                               int[] outputPtr,
                                                               @Cast(value="size_t")
                                                               long num)

curandGenerateLongLong
```
@Cast(value="curandStatus_t")
public static int curandGenerateLongLong(curandGenerator_st generator,
                                                                       @Cast(value="unsigned long long*")
                                                                       LongPointer outputPtr,
                                                                       @Cast(value="size_t")
                                                                       long num)
```
\brief Generate 64-bit quasirandom numbers. Use \p generator to generate \p num 64-bit results into the device memory at \p outputPtr. The device memory must have been previously allocated and be large enough to hold all the results. Launches are done with the stream set using ::curandSetStream(), or the null stream if no stream has been set. Results are 64-bit values with every bit random.

Parameters:

generator - - Generator to use

outputPtr - - Pointer to device memory to store CUDA-generated results, or Pointer to host memory to store CPU-generated results

num - - Number of random 64-bit values to generate

Returns:

- CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch \n - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension \n - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n - CURAND_STATUS_TYPE_ERROR if the generator is not a 64 bit quasirandom generator\n - CURAND_STATUS_SUCCESS if the results were generated successfully \n

curandGenerateLongLong

@Cast(value="curandStatus_t")
public static int curandGenerateLongLong(curandGenerator_st generator,
                                                                       @Cast(value="unsigned long long*")
                                                                       LongBuffer outputPtr,
                                                                       @Cast(value="size_t")
                                                                       long num)

curandGenerateLongLong

@Cast(value="curandStatus_t")
public static int curandGenerateLongLong(curandGenerator_st generator,
                                                                       @Cast(value="unsigned long long*")
                                                                       long[] outputPtr,
                                                                       @Cast(value="size_t")
                                                                       long num)

curandGenerateUniform
```
@Cast(value="curandStatus_t")
public static int curandGenerateUniform(curandGenerator_st generator,
                                                                      FloatPointer outputPtr,
                                                                      @Cast(value="size_t")
                                                                      long num)
```
\brief Generate uniformly distributed floats. Use \p generator to generate \p num float results into the device memory at \p outputPtr. The device memory must have been previously allocated and be large enough to hold all the results. Launches are done with the stream set using ::curandSetStream(), or the null stream if no stream has been set. Results are 32-bit floating point values between \p 0.0f and \p 1.0f, excluding \p 0.0f and including \p 1.0f.

Parameters:

generator - - Generator to use

outputPtr - - Pointer to device memory to store CUDA-generated results, or Pointer to host memory to store CPU-generated results

num - - Number of floats to generate

Returns:

- CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch \n - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension \n - CURAND_STATUS_SUCCESS if the results were generated successfully \n

curandGenerateUniform

@Cast(value="curandStatus_t")
public static int curandGenerateUniform(curandGenerator_st generator,
                                                                      FloatBuffer outputPtr,
                                                                      @Cast(value="size_t")
                                                                      long num)

curandGenerateUniform

@Cast(value="curandStatus_t")
public static int curandGenerateUniform(curandGenerator_st generator,
                                                                      float[] outputPtr,
                                                                      @Cast(value="size_t")
                                                                      long num)

curandGenerateUniformDouble
```
@Cast(value="curandStatus_t")
public static int curandGenerateUniformDouble(curandGenerator_st generator,
                                                                            DoublePointer outputPtr,
                                                                            @Cast(value="size_t")
                                                                            long num)
```
\brief Generate uniformly distributed doubles. Use \p generator to generate \p num double results into the device memory at \p outputPtr. The device memory must have been previously allocated and be large enough to hold all the results. Launches are done with the stream set using ::curandSetStream(), or the null stream if no stream has been set. Results are 64-bit double precision floating point values between \p 0.0 and \p 1.0, excluding \p 0.0 and including \p 1.0.

Parameters:

generator - - Generator to use

outputPtr - - Pointer to device memory to store CUDA-generated results, or Pointer to host memory to store CPU-generated results

num - - Number of doubles to generate

Returns:

- CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch \n - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension \n - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision \n - CURAND_STATUS_SUCCESS if the results were generated successfully \n

curandGenerateUniformDouble

@Cast(value="curandStatus_t")
public static int curandGenerateUniformDouble(curandGenerator_st generator,
                                                                            DoubleBuffer outputPtr,
                                                                            @Cast(value="size_t")
                                                                            long num)

curandGenerateUniformDouble

@Cast(value="curandStatus_t")
public static int curandGenerateUniformDouble(curandGenerator_st generator,
                                                                            double[] outputPtr,
                                                                            @Cast(value="size_t")
                                                                            long num)

curandGenerateNormal
```
@Cast(value="curandStatus_t")
public static int curandGenerateNormal(curandGenerator_st generator,
                                                                     FloatPointer outputPtr,
                                                                     @Cast(value="size_t")
                                                                     long n,
                                                                     float mean,
                                                                     float stddev)
```
\brief Generate normally distributed doubles. Use \p generator to generate \p n float results into the device memory at \p outputPtr. The device memory must have been previously allocated and be large enough to hold all the results. Launches are done with the stream set using ::curandSetStream(), or the null stream if no stream has been set. Results are 32-bit floating point values with mean \p mean and standard deviation \p stddev. Normally distributed results are generated from pseudorandom generators with a Box-Muller transform, and so require \p n to be even. Quasirandom generators use an inverse cumulative distribution function to preserve dimensionality. There may be slight numerical differences between results generated on the GPU with generators created with ::curandCreateGenerator() and results calculated on the CPU with generators created with ::curandCreateGeneratorHost(). These differences arise because of differences in results for transcendental functions. In addition, future versions of CURAND may use newer versions of the CUDA math library, so different versions of CURAND may give slightly different numerical values.

Parameters:

generator - - Generator to use

outputPtr - - Pointer to device memory to store CUDA-generated results, or Pointer to host memory to store CPU-generated results

n - - Number of floats to generate

mean - - Mean of normal distribution

stddev - - Standard deviation of normal distribution

Returns:

- CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch \n - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension, or is not a multiple of two for pseudorandom generators \n - CURAND_STATUS_SUCCESS if the results were generated successfully \n

curandGenerateNormal

@Cast(value="curandStatus_t")
public static int curandGenerateNormal(curandGenerator_st generator,
                                                                     FloatBuffer outputPtr,
                                                                     @Cast(value="size_t")
                                                                     long n,
                                                                     float mean,
                                                                     float stddev)

curandGenerateNormal

@Cast(value="curandStatus_t")
public static int curandGenerateNormal(curandGenerator_st generator,
                                                                     float[] outputPtr,
                                                                     @Cast(value="size_t")
                                                                     long n,
                                                                     float mean,
                                                                     float stddev)

curandGenerateNormalDouble
```
@Cast(value="curandStatus_t")
public static int curandGenerateNormalDouble(curandGenerator_st generator,
                                                                           DoublePointer outputPtr,
                                                                           @Cast(value="size_t")
                                                                           long n,
                                                                           double mean,
                                                                           double stddev)
```
\brief Generate normally distributed doubles. Use \p generator to generate \p n double results into the device memory at \p outputPtr. The device memory must have been previously allocated and be large enough to hold all the results. Launches are done with the stream set using ::curandSetStream(), or the null stream if no stream has been set. Results are 64-bit floating point values with mean \p mean and standard deviation \p stddev. Normally distributed results are generated from pseudorandom generators with a Box-Muller transform, and so require \p n to be even. Quasirandom generators use an inverse cumulative distribution function to preserve dimensionality. There may be slight numerical differences between results generated on the GPU with generators created with ::curandCreateGenerator() and results calculated on the CPU with generators created with ::curandCreateGeneratorHost(). These differences arise because of differences in results for transcendental functions. In addition, future versions of CURAND may use newer versions of the CUDA math library, so different versions of CURAND may give slightly different numerical values.

Parameters:

generator - - Generator to use

outputPtr - - Pointer to device memory to store CUDA-generated results, or Pointer to host memory to store CPU-generated results

n - - Number of doubles to generate

mean - - Mean of normal distribution

stddev - - Standard deviation of normal distribution

Returns:

- CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch \n - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension, or is not a multiple of two for pseudorandom generators \n - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision \n - CURAND_STATUS_SUCCESS if the results were generated successfully \n

curandGenerateNormalDouble

@Cast(value="curandStatus_t")
public static int curandGenerateNormalDouble(curandGenerator_st generator,
                                                                           DoubleBuffer outputPtr,
                                                                           @Cast(value="size_t")
                                                                           long n,
                                                                           double mean,
                                                                           double stddev)

curandGenerateNormalDouble

@Cast(value="curandStatus_t")
public static int curandGenerateNormalDouble(curandGenerator_st generator,
                                                                           double[] outputPtr,
                                                                           @Cast(value="size_t")
                                                                           long n,
                                                                           double mean,
                                                                           double stddev)

curandGenerateLogNormal
```
@Cast(value="curandStatus_t")
public static int curandGenerateLogNormal(curandGenerator_st generator,
                                                                        FloatPointer outputPtr,
                                                                        @Cast(value="size_t")
                                                                        long n,
                                                                        float mean,
                                                                        float stddev)
```
\brief Generate log-normally distributed floats. Use \p generator to generate \p n float results into the device memory at \p outputPtr. The device memory must have been previously allocated and be large enough to hold all the results. Launches are done with the stream set using ::curandSetStream(), or the null stream if no stream has been set. Results are 32-bit floating point values with log-normal distribution based on an associated normal distribution with mean \p mean and standard deviation \p stddev. Normally distributed results are generated from pseudorandom generators with a Box-Muller transform, and so require \p n to be even. Quasirandom generators use an inverse cumulative distribution function to preserve dimensionality. The normally distributed results are transformed into log-normal distribution. There may be slight numerical differences between results generated on the GPU with generators created with ::curandCreateGenerator() and results calculated on the CPU with generators created with ::curandCreateGeneratorHost(). These differences arise because of differences in results for transcendental functions. In addition, future versions of CURAND may use newer versions of the CUDA math library, so different versions of CURAND may give slightly different numerical values.

Parameters:

generator - - Generator to use

outputPtr - - Pointer to device memory to store CUDA-generated results, or Pointer to host memory to store CPU-generated results

n - - Number of floats to generate

mean - - Mean of associated normal distribution

stddev - - Standard deviation of associated normal distribution

Returns:

- CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch \n - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension, or is not a multiple of two for pseudorandom generators \n - CURAND_STATUS_SUCCESS if the results were generated successfully \n

curandGenerateLogNormal

@Cast(value="curandStatus_t")
public static int curandGenerateLogNormal(curandGenerator_st generator,
                                                                        FloatBuffer outputPtr,
                                                                        @Cast(value="size_t")
                                                                        long n,
                                                                        float mean,
                                                                        float stddev)

curandGenerateLogNormal

@Cast(value="curandStatus_t")
public static int curandGenerateLogNormal(curandGenerator_st generator,
                                                                        float[] outputPtr,
                                                                        @Cast(value="size_t")
                                                                        long n,
                                                                        float mean,
                                                                        float stddev)

curandGenerateLogNormalDouble
```
@Cast(value="curandStatus_t")
public static int curandGenerateLogNormalDouble(curandGenerator_st generator,
                                                                              DoublePointer outputPtr,
                                                                              @Cast(value="size_t")
                                                                              long n,
                                                                              double mean,
                                                                              double stddev)
```
\brief Generate log-normally distributed doubles. Use \p generator to generate \p n double results into the device memory at \p outputPtr. The device memory must have been previously allocated and be large enough to hold all the results. Launches are done with the stream set using ::curandSetStream(), or the null stream if no stream has been set. Results are 64-bit floating point values with log-normal distribution based on an associated normal distribution with mean \p mean and standard deviation \p stddev. Normally distributed results are generated from pseudorandom generators with a Box-Muller transform, and so require \p n to be even. Quasirandom generators use an inverse cumulative distribution function to preserve dimensionality. The normally distributed results are transformed into log-normal distribution. There may be slight numerical differences between results generated on the GPU with generators created with ::curandCreateGenerator() and results calculated on the CPU with generators created with ::curandCreateGeneratorHost(). These differences arise because of differences in results for transcendental functions. In addition, future versions of CURAND may use newer versions of the CUDA math library, so different versions of CURAND may give slightly different numerical values.

Parameters:

generator - - Generator to use

outputPtr - - Pointer to device memory to store CUDA-generated results, or Pointer to host memory to store CPU-generated results

n - - Number of doubles to generate

mean - - Mean of normal distribution

stddev - - Standard deviation of normal distribution

Returns:

- CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch \n - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension, or is not a multiple of two for pseudorandom generators \n - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision \n - CURAND_STATUS_SUCCESS if the results were generated successfully \n

curandGenerateLogNormalDouble

@Cast(value="curandStatus_t")
public static int curandGenerateLogNormalDouble(curandGenerator_st generator,
                                                                              DoubleBuffer outputPtr,
                                                                              @Cast(value="size_t")
                                                                              long n,
                                                                              double mean,
                                                                              double stddev)

curandGenerateLogNormalDouble

@Cast(value="curandStatus_t")
public static int curandGenerateLogNormalDouble(curandGenerator_st generator,
                                                                              double[] outputPtr,
                                                                              @Cast(value="size_t")
                                                                              long n,
                                                                              double mean,
                                                                              double stddev)

curandCreatePoissonDistribution
```
@Cast(value="curandStatus_t")
public static int curandCreatePoissonDistribution(double lambda,
                                                                                @ByPtrPtr
                                                                                curandDiscreteDistribution_st discrete_distribution)
```
\brief Construct the histogram array for a Poisson distribution. Construct the histogram array for the Poisson distribution with lambda \p lambda. For lambda greater than 2000, an approximation with a normal distribution is used.

Parameters:

lambda - - lambda for the Poisson distribution

discrete_distribution - - pointer to the histogram in device memory

Returns:

- CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision \n - CURAND_STATUS_INITIALIZATION_FAILED if there was a problem setting up the GPU \n - CURAND_STATUS_NOT_INITIALIZED if the distribution pointer was null \n - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch \n - CURAND_STATUS_OUT_OF_RANGE if lambda is non-positive or greater than 400,000 \n - CURAND_STATUS_SUCCESS if the histogram was generated successfully \n

curandDestroyDistribution
```
@Cast(value="curandStatus_t")
public static int curandDestroyDistribution(curandDiscreteDistribution_st discrete_distribution)
```
\brief Destroy the histogram array for a discrete distribution (e.g. Poisson). Destroy the histogram array for a discrete distribution created by curandCreatePoissonDistribution.

Parameters:

discrete_distribution - - pointer to device memory where the histogram is stored

Returns:

- CURAND_STATUS_NOT_INITIALIZED if the histogram was never created \n - CURAND_STATUS_SUCCESS if the histogram was destroyed successfully \n

curandGeneratePoisson
```
@Cast(value="curandStatus_t")
public static int curandGeneratePoisson(curandGenerator_st generator,
                                                                      @Cast(value="unsigned int*")
                                                                      IntPointer outputPtr,
                                                                      @Cast(value="size_t")
                                                                      long n,
                                                                      double lambda)
```
\brief Generate Poisson-distributed unsigned ints. Use \p generator to generate \p n unsigned int results into device memory at \p outputPtr. The device memory must have been previously allocated and must be large enough to hold all the results. Launches are done with the stream set using ::curandSetStream(), or the null stream if no stream has been set. Results are 32-bit unsigned int point values with Poisson distribution, with lambda \p lambda.

Parameters:

generator - - Generator to use

outputPtr - - Pointer to device memory to store CUDA-generated results, or Pointer to host memory to store CPU-generated results

n - - Number of unsigned ints to generate

lambda - - lambda for the Poisson distribution

Returns:

- CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch \n - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension\n - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU or sm does not support double precision \n - CURAND_STATUS_OUT_OF_RANGE if lambda is non-positive or greater than 400,000 \n - CURAND_STATUS_SUCCESS if the results were generated successfully \n

curandGeneratePoisson

@Cast(value="curandStatus_t")
public static int curandGeneratePoisson(curandGenerator_st generator,
                                                                      @Cast(value="unsigned int*")
                                                                      IntBuffer outputPtr,
                                                                      @Cast(value="size_t")
                                                                      long n,
                                                                      double lambda)

curandGeneratePoisson

@Cast(value="curandStatus_t")
public static int curandGeneratePoisson(curandGenerator_st generator,
                                                                      @Cast(value="unsigned int*")
                                                                      int[] outputPtr,
                                                                      @Cast(value="size_t")
                                                                      long n,
                                                                      double lambda)

curandGeneratePoissonMethod

@Cast(value="curandStatus_t")
public static int curandGeneratePoissonMethod(curandGenerator_st generator,
                                                                            @Cast(value="unsigned int*")
                                                                            IntPointer outputPtr,
                                                                            @Cast(value="size_t")
                                                                            long n,
                                                                            double lambda,
                                                                            @Cast(value="curandMethod_t")
                                                                            int method)

curandGeneratePoissonMethod

@Cast(value="curandStatus_t")
public static int curandGeneratePoissonMethod(curandGenerator_st generator,
                                                                            @Cast(value="unsigned int*")
                                                                            IntBuffer outputPtr,
                                                                            @Cast(value="size_t")
                                                                            long n,
                                                                            double lambda,
                                                                            @Cast(value="curandMethod_t")
                                                                            int method)

curandGeneratePoissonMethod

@Cast(value="curandStatus_t")
public static int curandGeneratePoissonMethod(curandGenerator_st generator,
                                                                            @Cast(value="unsigned int*")
                                                                            int[] outputPtr,
                                                                            @Cast(value="size_t")
                                                                            long n,
                                                                            double lambda,
                                                                            @Cast(value="curandMethod_t")
                                                                            int method)

curandGenerateSeeds
```
@Cast(value="curandStatus_t")
public static int curandGenerateSeeds(curandGenerator_st generator)
```
\brief Setup starting states. Generate the starting state of the generator. This function is automatically called by generation functions such as ::curandGenerate() and ::curandGenerateUniform(). It can be called manually for performance testing reasons to separate timings for starting state generation and random number generation.

Parameters:

generator - - Generator to update

Returns:

- CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch \n - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n - CURAND_STATUS_SUCCESS if the seeds were generated successfully \n

curandGetDirectionVectors32
```
@Cast(value="curandStatus_t")
public static int curandGetDirectionVectors32(@Cast(value="curandDirectionVectors32_t**")
                                                                            PointerPointer vectors,
                                                                            @Cast(value="curandDirectionVectorSet_t")
                                                                            int set)
```
\brief Get direction vectors for 32-bit quasirandom number generation. Get a pointer to an array of direction vectors that can be used for quasirandom number generation. The resulting pointer will reference an array of direction vectors in host memory. The array contains vectors for many dimensions. Each dimension has 32 vectors. Each individual vector is an unsigned int. Legal values for \p set are: - CURAND_DIRECTION_VECTORS_32_JOEKUO6 (20,000 dimensions) - CURAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6 (20,000 dimensions)

Parameters:

vectors - - Address of pointer in which to return direction vectors

set - - Which set of direction vectors to use

Returns:

- CURAND_STATUS_OUT_OF_RANGE if the choice of set is invalid \n - CURAND_STATUS_SUCCESS if the pointer was set successfully \n

curandGetDirectionVectors32

@Cast(value="curandStatus_t")
public static int curandGetDirectionVectors32(@Cast(value="curandDirectionVectors32_t**") @ByPtrPtr
                                                                            IntPointer vectors,
                                                                            @Cast(value="curandDirectionVectorSet_t")
                                                                            int set)

curandGetDirectionVectors32

@Cast(value="curandStatus_t")
public static int curandGetDirectionVectors32(@Cast(value="curandDirectionVectors32_t**") @ByPtrPtr
                                                                            IntBuffer vectors,
                                                                            @Cast(value="curandDirectionVectorSet_t")
                                                                            int set)

curandGetDirectionVectors32

@Cast(value="curandStatus_t")
public static int curandGetDirectionVectors32(@Cast(value="curandDirectionVectors32_t**") @ByPtrPtr
                                                                            int[] vectors,
                                                                            @Cast(value="curandDirectionVectorSet_t")
                                                                            int set)

curandGetScrambleConstants32
```
@Cast(value="curandStatus_t")
public static int curandGetScrambleConstants32(@Cast(value="unsigned int**")
                                                                             PointerPointer constants)
```
\brief Get scramble constants for 32-bit scrambled Sobol' . Get a pointer to an array of scramble constants that can be used for quasirandom number generation. The resulting pointer will reference an array of unsinged ints in host memory. The array contains constants for many dimensions. Each dimension has a single unsigned int constant.

Parameters:

constants - - Address of pointer in which to return scramble constants

Returns:

- CURAND_STATUS_SUCCESS if the pointer was set successfully \n

curandGetScrambleConstants32

@Cast(value="curandStatus_t")
public static int curandGetScrambleConstants32(@Cast(value="unsigned int**") @ByPtrPtr
                                                                             IntPointer constants)

curandGetScrambleConstants32

@Cast(value="curandStatus_t")
public static int curandGetScrambleConstants32(@Cast(value="unsigned int**") @ByPtrPtr
                                                                             IntBuffer constants)

curandGetScrambleConstants32

@Cast(value="curandStatus_t")
public static int curandGetScrambleConstants32(@Cast(value="unsigned int**") @ByPtrPtr
                                                                             int[] constants)

curandGetDirectionVectors64
```
@Cast(value="curandStatus_t")
public static int curandGetDirectionVectors64(@Cast(value="curandDirectionVectors64_t**")
                                                                            PointerPointer vectors,
                                                                            @Cast(value="curandDirectionVectorSet_t")
                                                                            int set)
```
\brief Get direction vectors for 64-bit quasirandom number generation. Get a pointer to an array of direction vectors that can be used for quasirandom number generation. The resulting pointer will reference an array of direction vectors in host memory. The array contains vectors for many dimensions. Each dimension has 64 vectors. Each individual vector is an unsigned long long. Legal values for \p set are: - CURAND_DIRECTION_VECTORS_64_JOEKUO6 (20,000 dimensions) - CURAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6 (20,000 dimensions)

Parameters:

vectors - - Address of pointer in which to return direction vectors

set - - Which set of direction vectors to use

Returns:

- CURAND_STATUS_OUT_OF_RANGE if the choice of set is invalid \n - CURAND_STATUS_SUCCESS if the pointer was set successfully \n

curandGetDirectionVectors64

@Cast(value="curandStatus_t")
public static int curandGetDirectionVectors64(@Cast(value="curandDirectionVectors64_t**") @ByPtrPtr
                                                                            LongPointer vectors,
                                                                            @Cast(value="curandDirectionVectorSet_t")
                                                                            int set)

curandGetDirectionVectors64

@Cast(value="curandStatus_t")
public static int curandGetDirectionVectors64(@Cast(value="curandDirectionVectors64_t**") @ByPtrPtr
                                                                            LongBuffer vectors,
                                                                            @Cast(value="curandDirectionVectorSet_t")
                                                                            int set)

curandGetDirectionVectors64

@Cast(value="curandStatus_t")
public static int curandGetDirectionVectors64(@Cast(value="curandDirectionVectors64_t**") @ByPtrPtr
                                                                            long[] vectors,
                                                                            @Cast(value="curandDirectionVectorSet_t")
                                                                            int set)

curandGetScrambleConstants64
```
@Cast(value="curandStatus_t")
public static int curandGetScrambleConstants64(@Cast(value="unsigned long long**")
                                                                             PointerPointer constants)
```
\brief Get scramble constants for 64-bit scrambled Sobol' . Get a pointer to an array of scramble constants that can be used for quasirandom number generation. The resulting pointer will reference an array of unsinged long longs in host memory. The array contains constants for many dimensions. Each dimension has a single unsigned long long constant.

Parameters:

constants - - Address of pointer in which to return scramble constants

Returns:

- CURAND_STATUS_SUCCESS if the pointer was set successfully \n

curandGetScrambleConstants64

@Cast(value="curandStatus_t")
public static int curandGetScrambleConstants64(@Cast(value="unsigned long long**") @ByPtrPtr
                                                                             LongPointer constants)

curandGetScrambleConstants64

@Cast(value="curandStatus_t")
public static int curandGetScrambleConstants64(@Cast(value="unsigned long long**") @ByPtrPtr
                                                                             LongBuffer constants)

curandGetScrambleConstants64

@Cast(value="curandStatus_t")
public static int curandGetScrambleConstants64(@Cast(value="unsigned long long**") @ByPtrPtr
                                                                             long[] constants)

Class curand

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.cuda.presets.curand

Methods inherited from class java.lang.Object

Field Detail

CURAND_VER_MAJOR

CURAND_VER_MINOR

CURAND_VER_PATCH

CURAND_VER_BUILD

CURAND_VERSION

CURAND_STATUS_SUCCESS

CURAND_STATUS_VERSION_MISMATCH

CURAND_STATUS_NOT_INITIALIZED

CURAND_STATUS_ALLOCATION_FAILED

CURAND_STATUS_TYPE_ERROR

CURAND_STATUS_OUT_OF_RANGE

CURAND_STATUS_LENGTH_NOT_MULTIPLE

CURAND_STATUS_DOUBLE_PRECISION_REQUIRED

CURAND_STATUS_LAUNCH_FAILURE

CURAND_STATUS_PREEXISTING_FAILURE

CURAND_STATUS_INITIALIZATION_FAILED

CURAND_STATUS_ARCH_MISMATCH

CURAND_STATUS_INTERNAL_ERROR

CURAND_RNG_TEST

CURAND_RNG_PSEUDO_DEFAULT

CURAND_RNG_PSEUDO_XORWOW

CURAND_RNG_PSEUDO_MRG32K3A

CURAND_RNG_PSEUDO_MTGP32

CURAND_RNG_PSEUDO_MT19937

CURAND_RNG_PSEUDO_PHILOX4_32_10

CURAND_RNG_QUASI_DEFAULT

CURAND_RNG_QUASI_SOBOL32

CURAND_RNG_QUASI_SCRAMBLED_SOBOL32

CURAND_RNG_QUASI_SOBOL64

CURAND_RNG_QUASI_SCRAMBLED_SOBOL64

CURAND_ORDERING_PSEUDO_BEST

CURAND_ORDERING_PSEUDO_DEFAULT

CURAND_ORDERING_PSEUDO_SEEDED

CURAND_ORDERING_PSEUDO_LEGACY

CURAND_ORDERING_PSEUDO_DYNAMIC

CURAND_ORDERING_QUASI_DEFAULT

CURAND_DIRECTION_VECTORS_32_JOEKUO6

CURAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6

CURAND_DIRECTION_VECTORS_64_JOEKUO6

CURAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6

CURAND_CHOOSE_BEST

CURAND_ITR

CURAND_KNUTH

CURAND_HITR

CURAND_M1

CURAND_M2

CURAND_BINARY_SEARCH

CURAND_DISCRETE_GAUSS

CURAND_REJECTION

CURAND_DEVICE_API

CURAND_FAST_REJECTION

CURAND_3RD

CURAND_DEFINITION

CURAND_POISSON

Constructor Detail

curand

Method Detail

curandCreateGenerator

curandCreateGeneratorHost

curandDestroyGenerator

curandGetVersion

curandGetVersion

curandGetVersion

curandGetProperty

curandGetProperty

curandGetProperty

curandSetStream

curandSetPseudoRandomGeneratorSeed

curandSetGeneratorOffset

curandSetGeneratorOrdering

curandSetQuasiRandomGeneratorDimensions

curandGenerate

curandGenerate