jcuda.jcurand

Class JCurand

java.lang.Object

jcuda.jcurand.JCurand

public class JCurand
extends Object

Java bindings for CURAND, the NVIDIA CUDA random number generation library.

The documentation is taken from the CURAND header files.

Method Summary

Modifier and Type	Method and Description
static int	curandCreateGenerator(curandGenerator generator, int rng_type) Create new random number generator.
static int	curandCreateGeneratorHost(curandGenerator generator, int rng_type) Create new host CPU random number generator.
static int	curandCreatePoissonDistribution(double lambda, curandDiscreteDistribution discrete_distribution) Construct the histogram array for a Poisson distribution.
static int	curandDestroyDistribution(curandDiscreteDistribution discrete_distribution) Destroy the histogram array for a discrete distribution (e.g.
static int	curandDestroyGenerator(curandGenerator generator) Destroy an existing generator.
static int	curandGenerate(curandGenerator generator, Pointer outputPtr, long num) Generate 32-bit pseudo or quasirandom numbers.
static int	curandGenerateLogNormal(curandGenerator generator, Pointer outputPtr, long n, float mean, float stddev) Generate log-normally distributed floats.
static int	curandGenerateLogNormalDouble(curandGenerator generator, Pointer outputPtr, long n, double mean, double stddev) Generate log-normally distributed doubles.
static int	curandGenerateLongLong(curandGenerator generator, Pointer outputPtr, long num) Generate 64-bit quasirandom numbers.
static int	curandGenerateNormal(curandGenerator generator, Pointer outputPtr, long n, float mean, float stddev) Generate normally distributed floats.
static int	curandGenerateNormalDouble(curandGenerator generator, Pointer outputPtr, long n, double mean, double stddev) Generate normally distributed doubles.
static int	curandGeneratePoisson(curandGenerator generator, Pointer outputPtr, long n, double lambda) Generate Poisson-distributed unsigned ints.
static int	curandGenerateSeeds(curandGenerator generator) Setup starting states.
static int	curandGenerateUniform(curandGenerator generator, Pointer outputPtr, long num) Generate uniformly distributed floats.
static int	curandGenerateUniformDouble(curandGenerator generator, Pointer outputPtr, long num) Generate uniformly distributed doubles.
static int	curandGetDirectionVectors32(int[][][] vectors, int set) Get direction vectors for 32-bit quasirandom number generation.
static int	curandGetDirectionVectors64(long[][][] vectors, int set) Get direction vectors for 64-bit quasirandom number generation.
static int	curandGetProperty(int type, int[] value) Obtains the value of the specified property.
static int	curandGetScrambleConstants32(int[][] constants) Get scramble constants for 32-bit scrambled Sobol' .
static int	curandGetScrambleConstants64(long[][] constants) Get scramble constants for 64-bit scrambled Sobol' .
static int	curandGetVersion(int[] version) Return the version number of the library.
static int	curandSetGeneratorOffset(curandGenerator generator, long offset) Set the absolute offset of the pseudo or quasirandom number generator.
static int	curandSetGeneratorOrdering(curandGenerator generator, int order) Set the ordering of results of the pseudo or quasirandom number generator.
static int	curandSetPseudoRandomGeneratorSeed(curandGenerator generator, long seed) Set the seed value of the pseudo-random number generator.
static int	curandSetQuasiRandomGeneratorDimensions(curandGenerator generator, int num_dimensions) Set the number of dimensions.
static int	curandSetStream(curandGenerator generator, cudaStream_t stream) Set the current stream for CURAND kernel launches.
static void	initialize() Initializes the native library.
static void	setExceptionsEnabled(boolean enabled) Enables or disables exceptions.
static void	setLogLevel(LogLevel logLevel) Set the specified log level for the JCurand library.

Methods inherited from class java.lang.Object

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

Method Detail

initialize

public static void initialize()

Initializes the native library. Note that this method does not have to be called explicitly, since it will be called automatically when this class is loaded.

setLogLevel

public static void setLogLevel(LogLevel logLevel)

Set the specified log level for the JCurand library.

Currently supported log levels:
LOG_QUIET: Never print anything
LOG_ERROR: Print error messages
LOG_TRACE: Print a trace of all native function calls

Parameters:

logLevel - The log level to use.

setExceptionsEnabled

public static void setExceptionsEnabled(boolean enabled)

Enables or disables exceptions. By default, the methods of this class only set the curandStatus from the native methods. If exceptions are enabled, a CudaException with a detailed error message will be thrown if a method is about to set a result code that is not curandStatus.CURAND_STATUS_SUCCESS

Parameters:

enabled - Whether exceptions are enabled

curandCreateGenerator

public static int curandCreateGenerator(curandGenerator generator,
                                        int rng_type)

 Create new random number generator.

 Creates a new random number generator of type rng_type
 and returns it in *generator.

 Legal values for 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 rng_type is CURAND_RNG_PSEUDO_DEFAULT, the type chosen
 is CURAND_RNG_PSEUDO_XORWOW.
 When rng_type is CURAND_RNG_QUASI_DEFAULT,
 the type chosen is CURAND_RNG_QUASI_SOBOL32.

 The default values for rng_type = CURAND_RNG_PSEUDO_XORWOW are:
 - seed = 0
 - offset = 0
 - ordering = CURAND_ORDERING_PSEUDO_DEFAULT

 The default values for rng_type = CURAND_RNG_PSEUDO_MRG32K3A are:
 - seed = 0
 - offset = 0
 - ordering = CURAND_ORDERING_PSEUDO_DEFAULT

 The default values for rng_type = CURAND_RNG_PSEUDO_MTGP32 are:
 - seed = 0
 - offset = 0
 - ordering = CURAND_ORDERING_PSEUDO_DEFAULT

 The default values for \p rng_type = CURAND_RNG_PSEUDO_MT19937 are:
 - seed = 0
 - offset = 0
 - ordering = CURAND_ORDERING_PSEUDO_DEFAULT

 The default values for rng_type = CURAND_RNG_PSEUDO_PHILOX4_32_10 are:
 - seed = 0
  - offset = 0
  - ordering = CURAND_ORDERING_PSEUDO_DEFAULT

 The default values for rng_type = CURAND_RNG_QUASI_SOBOL32 are:
 - dimensions = 1
 - offset = 0
 - ordering = CURAND_ORDERING_QUASI_DEFAULT

 The default values for rng_type = CURAND_RNG_QUASI_SOBOL64 are:
 - dimensions = 1
 - offset = 0
 - ordering = CURAND_ORDERING_QUASI_DEFAULT

 The default values for rng_type = CURAND_RNG_QUASI_SCRAMBBLED_SOBOL32 are:
 - dimensions = 1
 - offset = 0
 - ordering = CURAND_ORDERING_QUASI_DEFAULT

 The default values for rng_type = CURAND_RNG_QUASI_SCRAMBLED_SOBOL64 are:
 - dimensions = 1
 - offset = 0
 - 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 CURAND_STATUS_INITIALIZATION_FAILED if there was a problem setting up the GPU CURAND_STATUS_VERSION_MISMATCH if the header file version does not match the dynamically linked library version CURAND_STATUS_TYPE_ERROR if the value for rng_type is invalid CURAND_STATUS_SUCCESS if generator was created successfully

curandCreateGeneratorHost

public static int curandCreateGeneratorHost(curandGenerator generator,
                                            int rng_type)

 Create new host CPU random number generator.

 Creates a new host CPU random number generator of type rng_type
 and returns it in *generator.

 Legal values for 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 rng_type is CURAND_RNG_PSEUDO_DEFAULT, the type chosen
 is CURAND_RNG_PSEUDO_XORWOW.
 When rng_type is CURAND_RNG_QUASI_DEFAULT,
 the type chosen is CURAND_RNG_QUASI_SOBOL32.

 The default values for rng_type = CURAND_RNG_PSEUDO_XORWOW are:
 - seed = 0
 - offset = 0
 - ordering = CURAND_ORDERING_PSEUDO_DEFAULT

 The default values for rng_type = CURAND_RNG_PSEUDO_MRG32K3A are:
 - seed = 0
 - offset = 0
 - ordering = CURAND_ORDERING_PSEUDO_DEFAULT

 The default values for rng_type = CURAND_RNG_PSEUDO_MTGP32 are:
 - seed = 0
 - offset = 0
 - ordering = CURAND_ORDERING_PSEUDO_DEFAULT

 The default values for \p rng_type = CURAND_RNG_PSEUDO_MT19937 are:
 - seed = 0
 - offset = 0
 - ordering = CURAND_ORDERING_PSEUDO_DEFAULT

 The default values for rng_type = CURAND_RNG_PSEUDO_PHILOX4_32_10 are:
 - seed = 0
 - offset = 0
 - ordering = CURAND_ORDERING_PSEUDO_DEFAULT

 The default values for rng_type = CURAND_RNG_QUASI_SOBOL32 are:
 - dimensions = 1
 - offset = 0
 - ordering = CURAND_ORDERING_QUASI_DEFAULT

 The default values for rng_type = CURAND_RNG_QUASI_SOBOL64 are:
 - dimensions = 1
 - offset = 0
 - ordering = CURAND_ORDERING_QUASI_DEFAULT

 The default values for rng_type = CURAND_RNG_QUASI_SCRAMBLED_SOBOL32 are:
 - dimensions = 1
 - offset = 0
 - ordering = CURAND_ORDERING_QUASI_DEFAULT

 The default values for rng_type = CURAND_RNG_QUASI_SCRAMBLED_SOBOL64 are:
 - dimensions = 1
 - offset = 0
 - 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 CURAND_STATUS_INITIALIZATION_FAILED if there was a problem setting up the GPU CURAND_STATUS_VERSION_MISMATCH if the header file version does not match the dynamically linked library version CURAND_STATUS_TYPE_ERROR if the value for rng_type is invalid CURAND_STATUS_SUCCESS if generator was created successfully

curandDestroyGenerator

public static int curandDestroyGenerator(curandGenerator generator)

 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 CURAND_STATUS_SUCCESS if generator was destroyed successfully

curandGetVersion

public static int curandGetVersion(int[] version)

 Return the version number of the library.

 Return in *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

curandGetProperty

public static int curandGetProperty(int type,
                                    int[] value)

Obtains the value of the specified property.

Parameters:

type - The libraryPropertyType

value - The value

Returns:

CUFFT_SUCCESS, CUFFT_INVALID_TYPE, CUFFT_INVALID_VALUE

curandSetStream

public static int curandSetStream(curandGenerator generator,
                                  cudaStream_t stream)

 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 CURAND_STATUS_SUCCESS if stream was set successfully

curandSetPseudoRandomGeneratorSeed

public static int curandSetPseudoRandomGeneratorSeed(curandGenerator generator,
                                                     long seed)

 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 CURAND_STATUS_TYPE_ERROR if the generator is not a pseudorandom number generator CURAND_STATUS_SUCCESS if generator seed was set successfully

curandSetGeneratorOffset

public static int curandSetGeneratorOffset(curandGenerator generator,
                                           long offset)

 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 CURAND_STATUS_SUCCESS if generator offset was set successfully

curandSetGeneratorOrdering

public static int curandSetGeneratorOrdering(curandGenerator generator,
                                             int order)

 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 order for pseudorandom generators are:
 - CURAND_ORDERING_PSEUDO_DEFAULT
 - CURAND_ORDERING_PSEUDO_BEST
 - CURAND_ORDERING_PSEUDO_SEEDED

 Legal values of 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 CURAND_STATUS_OUT_OF_RANGE if the ordering is not valid CURAND_STATUS_SUCCESS if generator ordering was set successfully

curandSetQuasiRandomGeneratorDimensions

public static int curandSetQuasiRandomGeneratorDimensions(curandGenerator generator,
                                                          int num_dimensions)

 Set the number of dimensions.

 Set the number of dimensions to be generated by the quasirandom number
 generator.

 Legal values for 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 CURAND_STATUS_OUT_OF_RANGE if num_dimensions is not valid CURAND_STATUS_TYPE_ERROR if the generator is not a quasirandom number generator CURAND_STATUS_SUCCESS if generator ordering was set successfully

curandGenerate

public static int curandGenerate(curandGenerator generator,
                                 Pointer outputPtr,
                                 long num)

 Generate 32-bit pseudo or quasirandom numbers.

 Use generator to generate num 32-bit results into the device memory at
 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 CURAND_STATUS_NOT_INITIALIZED if the generator was never created CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason CURAND_STATUS_SUCCESS if the results were generated successfully

curandGenerateLongLong

public static int curandGenerateLongLong(curandGenerator generator,
                                         Pointer outputPtr,
                                         long num)

 Generate 64-bit quasirandom numbers.

 Use generator to generate num 64-bit results into the device memory at
 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 CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason CURAND_STATUS_SUCCESS if the results were generated successfully

curandGenerateUniform

public static int curandGenerateUniform(curandGenerator generator,
                                        Pointer outputPtr,
                                        long num)

 Generate uniformly distributed floats.

 Use generator to generate num float results into the device memory at
 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 0.0f and 1.0f,
 excluding 0.0f and including 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 CURAND_STATUS_NOT_INITIALIZED if the generator was never created CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension CURAND_STATUS_SUCCESS if the results were generated successfully

curandGenerateUniformDouble

public static int curandGenerateUniformDouble(curandGenerator generator,
                                              Pointer outputPtr,
                                              long num)

 Generate uniformly distributed doubles.

 Use generator to generate num double results into the device memory at
 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
 0.0 and 1.0, excluding 0.0 and including 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 CURAND_STATUS_NOT_INITIALIZED if the generator was never created CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision CURAND_STATUS_SUCCESS if the results were generated successfully

curandGenerateNormal

public static int curandGenerateNormal(curandGenerator generator,
                                       Pointer outputPtr,
                                       long n,
                                       float mean,
                                       float stddev)

 Generate normally distributed floats.

 Use generator to generate num float results into the device memory at
 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 mean and standard
 deviation stddev.

 Normally distributed results are generated from pseudorandom generators
 with a Box-Muller transform, and so require num 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 CURAND_STATUS_NOT_INITIALIZED if the generator was never created CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason 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 CURAND_STATUS_SUCCESS if the results were generated successfully

curandGenerateNormalDouble

public static int curandGenerateNormalDouble(curandGenerator generator,
                                             Pointer outputPtr,
                                             long n,
                                             double mean,
                                             double stddev)

 Generate normally distributed doubles.

 Use generator to generate num double results into the device memory at
 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 mean and standard
 deviation stddev.

 Normally distributed results are generated from pseudorandom generators
 with a Box-Muller transform, and so require num 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 CURAND_STATUS_NOT_INITIALIZED if the generator was never created CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason 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 CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision CURAND_STATUS_SUCCESS if the results were generated successfully

curandGenerateLogNormal

public static int curandGenerateLogNormal(curandGenerator generator,
                                          Pointer outputPtr,
                                          long n,
                                          float mean,
                                          float stddev)

 Generate log-normally distributed floats.

 Use generator to generate num float results into the device memory at
 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 mean and standard deviation stddev.

 Normally distributed results are generated from pseudorandom generators
 with a Box-Muller transform, and so require num 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 CURAND_STATUS_NOT_INITIALIZED if the generator was never created CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason 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 CURAND_STATUS_SUCCESS if the results were generated successfully

curandGenerateLogNormalDouble

public static int curandGenerateLogNormalDouble(curandGenerator generator,
                                                Pointer outputPtr,
                                                long n,
                                                double mean,
                                                double stddev)

 Generate log-normally distributed doubles.

 Use generator to generate num double results into the device memory at
 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 mean and standard deviation stddev.

 Normally distributed results are generated from pseudorandom generators
 with a Box-Muller transform, and so require num 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 CURAND_STATUS_NOT_INITIALIZED if the generator was never created CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason 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 CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision CURAND_STATUS_SUCCESS if the results were generated successfully

curandCreatePoissonDistribution

public static int curandCreatePoissonDistribution(double lambda,
                                                  curandDiscreteDistribution discrete_distribution)

 Construct the histogram array for a Poisson distribution.

 Construct the histogram array for the Poisson distribution with lambda 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 - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision - CURAND_STATUS_INITIALIZATION_FAILED if there was a problem setting up the GPU - CURAND_STATUS_NOT_INITIALIZED if the distribution pointer was null - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch - CURAND_STATUS_OUT_OF_RANGE if lambda is non-positive or greater than 400,000 - CURAND_STATUS_SUCCESS if the histogram was generated successfully (Note: This function actually belongs to the device API of CURAND, and may not be used sensibly from Java)

curandDestroyDistribution

public static int curandDestroyDistribution(curandDiscreteDistribution discrete_distribution)

 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 - CURAND_STATUS_SUCCESS if the histogram was destroyed successfully (Note: This function actually belongs to the device API of CURAND, and may not be used sensibly from Java)

curandGeneratePoisson

public static int curandGeneratePoisson(curandGenerator generator,
                                        Pointer outputPtr,
                                        long n,
                                        double lambda)

 Generate Poisson-distributed unsigned ints.

 Use generator to generate n unsigned int results into device memory at
 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 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 - CURAND_STATUS_NOT_INITIALIZED if the generator was never created - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is not a multiple of the quasirandom dimension - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU or sm does not support double precision - CURAND_STATUS_OUT_OF_RANGE if lambda is non-positive or greater than 400,000 - CURAND_STATUS_SUCCESS if the results were generated successfully

curandGenerateSeeds

public static int curandGenerateSeeds(curandGenerator generator)

 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 CURAND_STATUS_NOT_INITIALIZED if the generator was never created CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from a previous kernel launch CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason CURAND_STATUS_SUCCESS if the seeds were generated successfully

curandGetDirectionVectors32

public static int curandGetDirectionVectors32(int[][][] vectors,
                                              int set)

 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 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 CURAND_STATUS_SUCCESS if the pointer was set successfully

curandGetScrambleConstants32

public static int curandGetScrambleConstants32(int[][] constants)

 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

curandGetDirectionVectors64

public static int curandGetDirectionVectors64(long[][][] vectors,
                                              int set)

 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 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 CURAND_STATUS_SUCCESS if the pointer was set successfully

curandGetScrambleConstants64

public static int curandGetScrambleConstants64(long[][] constants)

 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