C/C++ API Reference#
This chapter describes the rocRAND C and C++ API.
Device Functions#
 group rocranddevice
Defines

ROCRAND_LFSR113_DEFAULT_SEED_X#
Default X seed for LFSR113 PRNG.

ROCRAND_LFSR113_DEFAULT_SEED_Y#
Default Y seed for LFSR113 PRNG.

ROCRAND_LFSR113_DEFAULT_SEED_Z#
Default Z seed for LFSR113 PRNG.

ROCRAND_LFSR113_DEFAULT_SEED_W#
Default W seed for LFSR113 PRNG.

ROCRAND_MRG31K3P_DEFAULT_SEED#
Default seed for MRG31K3P PRNG.

ROCRAND_MRG32K3A_DEFAULT_SEED#
Default seed for MRG32K3A PRNG.

ROCRAND_PHILOX4x32_DEFAULT_SEED#
Default seed for PHILOX4x32 PRNG.

FQUALIFIERS#
Shorthand for commonly used function qualifiers.

ROCRAND_XORWOW_DEFAULT_SEED#
Default seed for XORWOW PRNG.
Functions
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_philox4x32_10 *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using Philox generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS uint4 rocrand_discrete4 (rocrand_state_philox4x32_10 *state, const rocrand_discrete_distribution discrete_distribution)
Returns four discrete distributed
unsigned int
values.Returns four
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using Philox generator instate
, and increments the position of the generator by four. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
Four
unsigned int
values distributed according todiscrete_distribution
asuint4
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_mrg31k3p *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using MRG31k3p generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_mrg32k3a *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using MRG32k3a generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_xorwow *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using XORWOW generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_mtgp32 *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using MTGP32 generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_sobol32 *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using SOBOL32 generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_scrambled_sobol32 *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to discrete distributiondiscrete_distribution
using SCRAMBLED_SOBOL32 generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_sobol64 *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned long long int
value.Returns a
unsigned long long int
distributed according to with discrete distributiondiscrete_distribution
using SOBOL64 generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned long long int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_scrambled_sobol64 *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned long long int
value.Returns a
unsigned long long int
distributed according to with discrete distributiondiscrete_distribution
using SCRAMBLED_SOBOL64 generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned long long int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_lfsr113 *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using LFSR113 generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_threefry2x32_20 *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using ThreeFry generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_threefry2x64_20 *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using ThreeFry generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_threefry4x32_20 *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using ThreeFry generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS unsigned int rocrand_discrete (rocrand_state_threefry4x64_20 *state, const rocrand_discrete_distribution discrete_distribution)
Returns a discrete distributed
unsigned int
value.Returns a
unsigned int
distributed according to with discrete distributiondiscrete_distribution
using ThreeFry generator instate
, and increments the position of the generator by one. Parameters:
state –  Pointer to a state to use
discrete_distribution –  Related discrete distribution
 Returns:
unsigned int
value distributed according todiscrete_distribution
 FQUALIFIERS void rocrand_init (const uint4 seed, const unsigned int subsequence, rocrand_state_lfsr113 *state)
Initializes LFSR113 state.
Initializes the LFSR113 generator
state
with the givenseed
,subsequence
, andoffset
. Parameters:
seed –  Value to use as a seed
subsequence –  Subsequence to start at
state –  Pointer to state to initialize
 FQUALIFIERS unsigned int rocrand (rocrand_state_lfsr113 *state)
Returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range.Generates and returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range using LFSR113 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
 Returns:
Pseudorandom value (32bit) as an
unsigned int
 FQUALIFIERS float rocrand_log_normal (rocrand_state_philox4x32_10 *state, float mean, float stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using Philox generator instate
, and increments position of the generator by one. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS float2 rocrand_log_normal2 (rocrand_state_philox4x32_10 *state, float mean, float stddev)
Returns two lognormally distributed
float
values.Generates and returns two lognormally distributed
float
values using Philox generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
float
value asfloat2
 FQUALIFIERS float4 rocrand_log_normal4 (rocrand_state_philox4x32_10 *state, float mean, float stddev)
Returns four lognormally distributed
float
values.Generates and returns four lognormally distributed
float
values using Philox generator instate
, and increments position of the generator by four. The function uses the BoxMuller transform method to generate four normally distributed values, transforms them to lognormally distributed values, and returns them. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Four lognormally distributed
float
value asfloat4
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_philox4x32_10 *state, double mean, double stddev)
Returns a lognormally distributed
double
values.Generates and returns a lognormally distributed
double
value using Philox generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributeddouble
values, transforms them to lognormally distributeddouble
values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS double2 rocrand_log_normal_double2 (rocrand_state_philox4x32_10 *state, double mean, double stddev)
Returns two lognormally distributed
double
values.Generates and returns two lognormally distributed
double
values using Philox generator instate
, and increments position of the generator by four. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
double
values asdouble2
 FQUALIFIERS double4 rocrand_log_normal_double4 (rocrand_state_philox4x32_10 *state, double mean, double stddev)
Returns four lognormally distributed
double
values.Generates and returns four lognormally distributed
double
values using Philox generator instate
, and increments position of the generator by eight. The function uses the BoxMuller transform method to generate four normally distributed values, transforms them to lognormally distributed values, and returns them. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Four lognormally distributed
double
values asdouble4
 FQUALIFIERS float rocrand_log_normal (rocrand_state_mrg31k3p *state, float mean, float stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using MRG31k3p generator instate
, and increments position of the generator by one. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS float2 rocrand_log_normal2 (rocrand_state_mrg31k3p *state, float mean, float stddev)
Returns two lognormally distributed
float
values.Generates and returns two lognormally distributed
float
values using MRG31k3p generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_mrg31k3p *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using MRG31k3p generator instate
, and increments position of the generator by one. The function uses the BoxMuller transform method to generate two normally distributeddouble
values, transforms them to lognormally distributeddouble
values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS double2 rocrand_log_normal_double2 (rocrand_state_mrg31k3p *state, double mean, double stddev)
Returns two lognormally distributed
double
values.Generates and returns two lognormally distributed
double
values using MRG31k3p generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
double
values asdouble2
 FQUALIFIERS float rocrand_log_normal (rocrand_state_mrg32k3a *state, float mean, float stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using MRG32k3a generator instate
, and increments position of the generator by one. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS float2 rocrand_log_normal2 (rocrand_state_mrg32k3a *state, float mean, float stddev)
Returns two lognormally distributed
float
values.Generates and returns two lognormally distributed
float
values using MRG32k3a generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_mrg32k3a *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using MRG32k3a generator instate
, and increments position of the generator by one. The function uses the BoxMuller transform method to generate two normally distributeddouble
values, transforms them to lognormally distributeddouble
values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS double2 rocrand_log_normal_double2 (rocrand_state_mrg32k3a *state, double mean, double stddev)
Returns two lognormally distributed
double
values.Generates and returns two lognormally distributed
double
values using MRG32k3a generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
double
values asdouble2
 FQUALIFIERS float rocrand_log_normal (rocrand_state_xorwow *state, float mean, float stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using XORWOW generator instate
, and increments position of the generator by one. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS float2 rocrand_log_normal2 (rocrand_state_xorwow *state, float mean, float stddev)
Returns two lognormally distributed
float
values.Generates and returns two lognormally distributed
float
values using XORWOW generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_xorwow *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using XORWOW generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributeddouble
values, transforms them to lognormally distributeddouble
values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS double2 rocrand_log_normal_double2 (rocrand_state_xorwow *state, double mean, double stddev)
Returns two lognormally distributed
double
values.Generates and returns two lognormally distributed
double
values using XORWOW generator instate
, and increments position of the generator by four. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
double
values asdouble2
 FQUALIFIERS float rocrand_log_normal (rocrand_state_mtgp32 *state, float mean, float stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using MTGP32 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_mtgp32 *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using MTGP32 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS float rocrand_log_normal (rocrand_state_sobol32 *state, float mean, float stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using SOBOL32 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_sobol32 *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using SOBOL32 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS float rocrand_log_normal (rocrand_state_scrambled_sobol32 *state, float mean, float stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using SCRAMBLED_SOBOL32 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_scrambled_sobol32 *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using SCRAMBLED_SOBOL32 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS float rocrand_log_normal (rocrand_state_sobol64 *state, float mean, float stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using SOBOL64 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_sobol64 *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using SOBOL64 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS float rocrand_log_normal (rocrand_state_scrambled_sobol64 *state, float mean, float stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using SCRAMBLED_SOBOL64 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_scrambled_sobol64 *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using SCRAMBLED_SOBOL64 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS float rocrand_log_normal (rocrand_state_lfsr113 *state, float mean, float stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using LFSR113 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS float2 rocrand_log_normal2 (rocrand_state_lfsr113 *state, float mean, float stddev)
Returns two lognormally distributed
float
values.Generates and returns two lognormally distributed
float
values using LFSR113 generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_lfsr113 *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using LFSR113 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS double2 rocrand_log_normal_double2 (rocrand_state_lfsr113 *state, double mean, double stddev)
Returns two lognormally distributed
double
values.Generates and returns two lognormally distributed
double
values using LFSR113 generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
double
values asdouble2
 FQUALIFIERS float rocrand_log_normal (rocrand_state_threefry2x32_20 *state, double mean, double stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS float2 rocrand_log_normal2 (rocrand_state_threefry2x32_20 *state, float mean, float stddev)
Returns two lognormally distributed
float
values.Generates and returns two lognormally distributed
float
values using Threefry generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_threefry2x32_20 *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS double2 rocrand_log_normal_double2 (rocrand_state_threefry2x32_20 *state, double mean, double stddev)
Returns two lognormally distributed
double
values.Generates and returns two lognormally distributed
double
values using Threefry generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
double
values asdouble2
 FQUALIFIERS float rocrand_log_normal (rocrand_state_threefry2x64_20 *state, double mean, double stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS float2 rocrand_log_normal2 (rocrand_state_threefry2x64_20 *state, float mean, float stddev)
Returns two lognormally distributed
float
values.Generates and returns two lognormally distributed
float
values using Threefry generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_threefry2x64_20 *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS double2 rocrand_log_normal_double2 (rocrand_state_threefry2x64_20 *state, double mean, double stddev)
Returns two lognormally distributed
double
values.Generates and returns two lognormally distributed
double
values using Threefry generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
double
values asdouble2
 FQUALIFIERS float rocrand_log_normal (rocrand_state_threefry4x32_20 *state, double mean, double stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS float2 rocrand_log_normal2 (rocrand_state_threefry4x32_20 *state, float mean, float stddev)
Returns two lognormally distributed
float
values.Generates and returns two lognormally distributed
float
values using THREEFRY generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_threefry4x32_20 *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS double2 rocrand_log_normal_double2 (rocrand_state_threefry4x32_20 *state, double mean, double stddev)
Returns two lognormally distributed
double
values.Generates and returns two lognormally distributed
double
values using Threefry generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
double
values asdouble2
 FQUALIFIERS float rocrand_log_normal (rocrand_state_threefry4x64_20 *state, double mean, double stddev)
Returns a lognormally distributed
float
value.Generates and returns a lognormally distributed
float
value using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
float
value
 FQUALIFIERS float2 rocrand_log_normal2 (rocrand_state_threefry4x64_20 *state, float mean, float stddev)
Returns two lognormally distributed
float
values.Generates and returns two lognormally distributed
float
values using Threefry generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_log_normal_double (rocrand_state_threefry4x64_20 *state, double mean, double stddev)
Returns a lognormally distributed
double
value.Generates and returns a lognormally distributed
double
value using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Lognormally distributed
double
value
 FQUALIFIERS double2 rocrand_log_normal_double2 (rocrand_state_threefry4x64_20 *state, double mean, double stddev)
Returns two lognormally distributed
double
values.Generates and returns two lognormally distributed
double
values using Threefry generator instate
, and increments position of the generator by two. The function uses the BoxMuller transform method to generate two normally distributed values, transforms them to lognormally distributed values, and returns both. Parameters:
state –  Pointer to a state to use
mean –  Mean of the related lognormal distribution
stddev –  Standard deviation of the related lognormal distribution
 Returns:
Two lognormally distributed
double
values asdouble2
 FQUALIFIERS void rocrand_init (const unsigned long long seed, const unsigned long long subsequence, const unsigned long long offset, rocrand_state_mrg31k3p *state)
Initializes MRG31K3P state.
Initializes the MRG31K3P generator
state
with the givenseed
,subsequence
, andoffset
. Parameters:
seed –  Value to use as a seed
subsequence –  Subsequence to start at
offset –  Absolute offset into subsequence
state –  Pointer to state to initialize
 FQUALIFIERS unsigned int rocrand (rocrand_state_mrg31k3p *state)
Returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range.Generates and returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range using MRG31K3P generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
 Returns:
Pseudorandom value (32bit) as an
unsigned int
 FQUALIFIERS void skipahead (unsigned long long offset, rocrand_state_mrg31k3p *state)
Updates MRG31K3P state to skip ahead by
offset
elements.Updates the MRG31K3P state in
state
to skip ahead byoffset
elements. Parameters:
offset –  Number of elements to skip
state –  Pointer to state to update
 FQUALIFIERS void skipahead_subsequence (unsigned long long subsequence, rocrand_state_mrg31k3p *state)
Updates MRG31K3P state to skip ahead by
subsequence
subsequences.Updates the MRG31K3P state in
state
to skip ahead bysubsequence
subsequences. Each subsequence is 2^72 numbers long. Parameters:
subsequence –  Number of subsequences to skip
state –  Pointer to state to update
 FQUALIFIERS void skipahead_sequence (unsigned long long sequence, rocrand_state_mrg31k3p *state)
Updates MRG31K3P state to skip ahead by
sequence
sequences.Updates the MRG31K3P state in
state
to skip ahead bysequence
sequences. Each sequence is 2^134 numbers long. Parameters:
sequence –  Number of sequences to skip
state –  Pointer to state to update
 FQUALIFIERS void rocrand_init (const unsigned long long seed, const unsigned long long subsequence, const unsigned long long offset, rocrand_state_mrg32k3a *state)
Initializes MRG32K3A state.
Initializes the MRG32K3A generator
state
with the givenseed
,subsequence
, andoffset
. Parameters:
seed –  Value to use as a seed
subsequence –  Subsequence to start at
offset –  Absolute offset into subsequence
state –  Pointer to state to initialize
 FQUALIFIERS unsigned int rocrand (rocrand_state_mrg32k3a *state)
Returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range.Generates and returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range using MRG32K3A generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
 Returns:
Pseudorandom value (32bit) as an
unsigned int
 FQUALIFIERS void skipahead (unsigned long long offset, rocrand_state_mrg32k3a *state)
Updates MRG32K3A state to skip ahead by
offset
elements.Updates the MRG32K3A state in
state
to skip ahead byoffset
elements. Parameters:
offset –  Number of elements to skip
state –  Pointer to state to update
 FQUALIFIERS void skipahead_subsequence (unsigned long long subsequence, rocrand_state_mrg32k3a *state)
Updates MRG32K3A state to skip ahead by
subsequence
subsequences.Updates the MRG32K3A state in
state
to skip ahead bysubsequence
subsequences. Each subsequence is 2^76 numbers long. Parameters:
subsequence –  Number of subsequences to skip
state –  Pointer to state to update
 FQUALIFIERS void skipahead_sequence (unsigned long long sequence, rocrand_state_mrg32k3a *state)
Updates MRG32K3A state to skip ahead by
sequence
sequences.Updates the MRG32K3A state in
state
to skip ahead bysequence
sequences. Each sequence is 2^127 numbers long. Parameters:
sequence –  Number of sequences to skip
state –  Pointer to state to update
 inline __host__ rocrand_status rocrand_make_state_mtgp32 (rocrand_state_mtgp32 *d_state, mtgp32_fast_params params[], int n, unsigned long long seed)
Initializes MTGP32 states.
Initializes MTGP32 states on the hostside by allocating a state array in host memory, initializes that array, and copies the result to device memory.
 Parameters:
d_state –  Pointer to an array of states in device memory
params –  Pointer to an array of type mtgp32_fast_params in host memory
n –  Number of states to initialize
seed –  Seed value
 Returns:
ROCRAND_STATUS_ALLOCATION_FAILED if states could not be initialized
ROCRAND_STATUS_SUCCESS if states are initialized
 inline __host__ rocrand_status rocrand_make_constant (const mtgp32_fast_params params[], mtgp32_params *p)
Loads parameters for MTGP32.
Loads parameters for use by kernel functions on the hostside and copies the results to the specified location in device memory.
NOTE: Not used as rocrand_make_state_mtgp32 handles loading parameters into state.
 Parameters:
params –  Pointer to an array of type mtgp32_fast_params in host memory
p –  Pointer to a mtgp32_params structure allocated in device memory
 Returns:
ROCRAND_STATUS_ALLOCATION_FAILED if parameters could not be loaded
ROCRAND_STATUS_SUCCESS if parameters are loaded
 FQUALIFIERS unsigned int rocrand (rocrand_state_mtgp32 *state)
Returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range.Generates and returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range using MTGP32 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
 Returns:
Pseudorandom value (32bit) as an
unsigned int
 FQUALIFIERS void rocrand_mtgp32_block_copy (rocrand_state_mtgp32 *src, rocrand_state_mtgp32 *dest)
Copies MTGP32 state to another state using block of threads.
Copies a MTGP32 state
src
todest
using a block of threads efficiently. Example usage would be:__global__ void generate_kernel(rocrand_state_mtgp32 * states, unsigned int * output, const size_t size) { const unsigned int state_id = blockIdx.x; unsigned int index = blockIdx.x * blockDim.x + threadIdx.x; unsigned int stride = gridDim.x * blockDim.x; __shared__ GeneratorState state; rocrand_mtgp32_block_copy(&states[state_id], &state); while(index < size) { output[index] = rocrand(&state); index += stride; } rocrand_mtgp32_block_copy(&state, &states[state_id]); }
 Parameters:
src –  Pointer to a state to copy from
dest –  Pointer to a state to copy to
 FQUALIFIERS void rocrand_mtgp32_set_params (rocrand_state_mtgp32 *state, mtgp32_params *params)
Changes parameters of a MTGP32 state.
 Parameters:
state –  Pointer to a MTGP32 state
params –  Pointer to new parameters
 FQUALIFIERS float rocrand_normal (rocrand_state_philox4x32_10 *state)
Returns a normally distributed
float
value.Generates and returns a normally distributed
float
value using Philox generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS float2 rocrand_normal2 (rocrand_state_philox4x32_10 *state)
Returns two normally distributed
float
values.Generates and returns two normally distributed
float
values using Philox generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
float
value asfloat2
 FQUALIFIERS float4 rocrand_normal4 (rocrand_state_philox4x32_10 *state)
Returns four normally distributed
float
values.Generates and returns four normally distributed
float
values using Philox generator instate
, and increments position of the generator by four. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate four normally distributed values, and returns them. Parameters:
state –  Pointer to a state to use
 Returns:
Four normally distributed
float
value asfloat4
 FQUALIFIERS double rocrand_normal_double (rocrand_state_philox4x32_10 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using Philox generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS double2 rocrand_normal_double2 (rocrand_state_philox4x32_10 *state)
Returns two normally distributed
double
values.Generates and returns two normally distributed
double
values using Philox generator instate
, and increments position of the generator by four. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
double
values asdouble2
 FQUALIFIERS double4 rocrand_normal_double4 (rocrand_state_philox4x32_10 *state)
Returns four normally distributed
double
values.Generates and returns four normally distributed
double
values using Philox generator instate
, and increments position of the generator by eight. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate four normally distributed values, and returns them. Parameters:
state –  Pointer to a state to use
 Returns:
Four normally distributed
double
values asdouble4
 FQUALIFIERS float rocrand_normal (rocrand_state_mrg31k3p *state)
Returns a normally distributed
float
value.Generates and returns a normally distributed
float
value using MRG31k3p generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS float2 rocrand_normal2 (rocrand_state_mrg31k3p *state)
Returns two normally distributed
float
values.Generates and returns two normally distributed
float
values using MRG31k3p generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_normal_double (rocrand_state_mrg31k3p *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using MRG31k3p generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS double2 rocrand_normal_double2 (rocrand_state_mrg31k3p *state)
Returns two normally distributed
double
values.Generates and returns two normally distributed
double
values using MRG31k3p generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
double
value asdouble2
 FQUALIFIERS float rocrand_normal (rocrand_state_mrg32k3a *state)
Returns a normally distributed
float
value.Generates and returns a normally distributed
float
value using MRG32k3a generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS float2 rocrand_normal2 (rocrand_state_mrg32k3a *state)
Returns two normally distributed
float
values.Generates and returns two normally distributed
float
values using MRG32k3a generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_normal_double (rocrand_state_mrg32k3a *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using MRG32k3a generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS double2 rocrand_normal_double2 (rocrand_state_mrg32k3a *state)
Returns two normally distributed
double
values.Generates and returns two normally distributed
double
values using MRG32k3a generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
double
value asdouble2
 FQUALIFIERS float rocrand_normal (rocrand_state_xorwow *state)
Returns a normally distributed
float
value.Generates and returns a normally distributed
float
value using XORWOW generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS float2 rocrand_normal2 (rocrand_state_xorwow *state)
Returns two normally distributed
float
values.Generates and returns two normally distributed
float
values using XORWOW generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
float
values asfloat2
 FQUALIFIERS double rocrand_normal_double (rocrand_state_xorwow *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using XORWOW generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, returns first of them, and saves the second to be returned on the next call. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS double2 rocrand_normal_double2 (rocrand_state_xorwow *state)
Returns two normally distributed
double
values.Generates and returns two normally distributed
double
values using XORWOW generator instate
, and increments position of the generator by four. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
double
value asdouble2
 FQUALIFIERS float rocrand_normal (rocrand_state_mtgp32 *state)
Returns a normally distributed
float
value.Generates and returns a normally distributed
float
value using MTGP32 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS double rocrand_normal_double (rocrand_state_mtgp32 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using MTGP32 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS float rocrand_normal (rocrand_state_sobol32 *state)
Returns a normally distributed
float
value.Generates and returns a normally distributed
float
value using SOBOL32 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS double rocrand_normal_double (rocrand_state_sobol32 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using SOBOL32 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS float rocrand_normal (rocrand_state_scrambled_sobol32 *state)
Returns a normally distributed
float
value.Generates and returns a normally distributed
float
value using SCRAMBLED_SOBOL32 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS double rocrand_normal_double (rocrand_state_scrambled_sobol32 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using SCRAMBLED_SOBOL32 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS float rocrand_normal (rocrand_state_sobol64 *state)
Returns a normally distributed
float
value.Generates and returns a normally distributed
float
value using SOBOL64 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS double rocrand_normal_double (rocrand_state_sobol64 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using SOBOL64 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS float rocrand_normal (rocrand_state_scrambled_sobol64 *state)
Returns a normally distributed
float
value.Generates and returns a normally distributed
float
value using SCRAMBLED_SOBOL64 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS double rocrand_normal_double (rocrand_state_scrambled_sobol64 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using SCRAMBLED_SOBOL64 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS float rocrand_normal (rocrand_state_lfsr113 *state)
Returns a normally distributed
float
value.Generates and returns a normally distributed
float
value using LFSR113 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS float2 rocrand_normal2 (rocrand_state_lfsr113 *state)
Returns two normally distributed
float
values.Generates and returns two normally distributed
float
values using LFSR113 generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_normal_double (rocrand_state_lfsr113 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using LFSR113 generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS double2 rocrand_normal_double2 (rocrand_state_lfsr113 *state)
Returns two normally distributed
double
values.Generates and returns two normally distributed
double
values using LFSR113 generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
double
value asdouble2
 FQUALIFIERS float rocrand_normal (rocrand_state_threefry2x32_20 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
float
value using ThreeFry generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS float2 rocrand_normal2 (rocrand_state_threefry2x32_20 *state)
Returns two normally distributed
float
values.Generates and returns two normally distributed
float
values using ThreeFry generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_normal_double (rocrand_state_threefry2x32_20 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using ThreeFry generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS double2 rocrand_normal_double2 (rocrand_state_threefry2x32_20 *state)
Returns two normally distributed
double
values.Generates and returns two normally distributed
double
values using ThreeFry generator instate
, and increments position of the generator by four. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
double
value asdouble2
 FQUALIFIERS float rocrand_normal (rocrand_state_threefry2x64_20 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
float
value using ThreeFry generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS float2 rocrand_normal2 (rocrand_state_threefry2x64_20 *state)
Returns two normally distributed
float
values.Generates and returns two normally distributed
float
values using ThreeFry generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_normal_double (rocrand_state_threefry2x64_20 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using ThreeFry generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS double2 rocrand_normal_double2 (rocrand_state_threefry2x64_20 *state)
Returns two normally distributed
double
values.Generates and returns two normally distributed
double
values using ThreeFry generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
double
value asdouble2
 FQUALIFIERS float rocrand_normal (rocrand_state_threefry4x32_20 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
float
value using ThreeFry generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS float2 rocrand_normal2 (rocrand_state_threefry4x32_20 *state)
Returns two normally distributed
float
values.Generates and returns two normally distributed
float
values using ThreeFry generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_normal_double (rocrand_state_threefry4x32_20 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using ThreeFry generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS double2 rocrand_normal_double2 (rocrand_state_threefry4x32_20 *state)
Returns two normally distributed
double
values.Generates and returns two normally distributed
double
values using ThreeFry generator instate
, and increments position of the generator by four. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
double
value asdouble2
 FQUALIFIERS float rocrand_normal (rocrand_state_threefry4x64_20 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
float
value using ThreeFry generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
float
value
 FQUALIFIERS float2 rocrand_normal2 (rocrand_state_threefry4x64_20 *state)
Returns two normally distributed
float
values.Generates and returns two normally distributed
float
values using ThreeFry generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
float
value asfloat2
 FQUALIFIERS double rocrand_normal_double (rocrand_state_threefry4x64_20 *state)
Returns a normally distributed
double
value.Generates and returns a normally distributed
double
value using ThreeFry generator instate
, and increments position of the generator by one. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. Parameters:
state –  Pointer to a state to use
 Returns:
Normally distributed
double
value
 FQUALIFIERS double2 rocrand_normal_double2 (rocrand_state_threefry4x64_20 *state)
Returns two normally distributed
double
values.Generates and returns two normally distributed
double
values using ThreeFry generator instate
, and increments position of the generator by two. Used normal distribution has mean value equal to 0.0f, and standard deviation equal to 1.0f. The function uses the BoxMuller transform method to generate two normally distributed values, and returns both of them. Parameters:
state –  Pointer to a state to use
 Returns:
Two normally distributed
double
value asdouble2
 FQUALIFIERS void rocrand_init (const unsigned long long seed, const unsigned long long subsequence, const unsigned long long offset, rocrand_state_philox4x32_10 *state)
Initializes Philox state.
Initializes the Philox generator
state
with the givenseed
,subsequence
, andoffset
. Parameters:
seed –  Value to use as a seed
subsequence –  Subsequence to start at
offset –  Absolute offset into subsequence
state –  Pointer to state to initialize
 FQUALIFIERS unsigned int rocrand (rocrand_state_philox4x32_10 *state)
Returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range.Generates and returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range using Philox generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
 Returns:
Pseudorandom value (32bit) as an
unsigned int
 FQUALIFIERS uint4 rocrand4 (rocrand_state_philox4x32_10 *state)
Returns four uniformly distributed random
unsigned int
values from [0; 2^32  1] range.Generates and returns four uniformly distributed random
unsigned int
values from [0; 2^32  1] range using Philox generator instate
. State is incremented by four positions. Parameters:
state –  Pointer to a state to use
 Returns:
Four pseudorandom values (32bit) as an
uint4
 FQUALIFIERS void skipahead (unsigned long long offset, rocrand_state_philox4x32_10 *state)
Updates Philox state to skip ahead by
offset
elements.Updates the Philox generator state in
state
to skip ahead byoffset
elements. Parameters:
offset –  Number of elements to skip
state –  Pointer to state to update
 FQUALIFIERS void skipahead_subsequence (unsigned long long subsequence, rocrand_state_philox4x32_10 *state)
Updates Philox state to skip ahead by
subsequence
subsequences.Updates the Philox generator state in
state
to skip ahead bysubsequence
subsequences. Each subsequence is 4 * 2^64 numbers long. Parameters:
subsequence –  Number of subsequences to skip
state –  Pointer to state to update
 FQUALIFIERS void skipahead_sequence (unsigned long long sequence, rocrand_state_philox4x32_10 *state)
Updates Philox state to skip ahead by
sequence
sequences.Updates the Philox generator state in
state
skippingsequence
sequences ahead. For Philox each sequence is 4 * 2^64 numbers long (equal to the size of a subsequence). Parameters:
sequence –  Number of sequences to skip
state –  Pointer to state to update
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_philox4x32_10 *state, double lambda)
Returns a Poissondistributed
unsigned int
using Philox generator.Generates and returns Poissondistributed distributed random
unsigned int
values using Philox generator instate
. State is incremented by a variable amount. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS uint4 rocrand_poisson4 (rocrand_state_philox4x32_10 *state, double lambda)
Returns four Poissondistributed
unsigned int
values using Philox generator.Generates and returns Poissondistributed distributed random
unsigned int
values using Philox generator instate
. State is incremented by a variable amount. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Four Poissondistributed
unsigned int
values asuint4
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_mrg31k3p *state, double lambda)
Returns a Poissondistributed
unsigned int
using MRG31k3p generator.Generates and returns Poissondistributed distributed random
unsigned int
values using MRG31k3p generator instate
. State is incremented by a variable amount. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_mrg32k3a *state, double lambda)
Returns a Poissondistributed
unsigned int
using MRG32k3a generator.Generates and returns Poissondistributed distributed random
unsigned int
values using MRG32k3a generator instate
. State is incremented by a variable amount. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_xorwow *state, double lambda)
Returns a Poissondistributed
unsigned int
using XORWOW generator.Generates and returns Poissondistributed distributed random
unsigned int
values using XORWOW generator instate
. State is incremented by a variable amount. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_mtgp32 *state, double lambda)
Returns a Poissondistributed
unsigned int
using MTGP32 generator.Generates and returns Poissondistributed distributed random
unsigned int
values using MTGP32 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_sobol32 *state, double lambda)
Returns a Poissondistributed
unsigned int
using SOBOL32 generator.Generates and returns Poissondistributed distributed random
unsigned int
values using SOBOL32 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_scrambled_sobol32 *state, double lambda)
Returns a Poissondistributed
unsigned int
using SCRAMBLED_SOBOL32 generator.Generates and returns Poissondistributed distributed random
unsigned int
values using SCRAMBLED_SOBOL32 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS unsigned long long int rocrand_poisson (rocrand_state_sobol64 *state, double lambda)
Returns a Poissondistributed
unsigned long long int
using SOBOL64 generator.Generates and returns Poissondistributed distributed random
unsigned long long int
values using SOBOL64 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned long long int
 FQUALIFIERS unsigned long long int rocrand_poisson (rocrand_state_scrambled_sobol64 *state, double lambda)
Returns a Poissondistributed
unsigned long long int
using SCRAMBLED_SOBOL64 generator.Generates and returns Poissondistributed distributed random
unsigned long long int
values using SCRAMBLED_SOBOL64 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned long long int
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_lfsr113 *state, double lambda)
Returns a Poissondistributed
unsigned int
using LFSR113 generator.Generates and returns Poissondistributed distributed random
unsigned int
values using LFSR113 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_threefry2x32_20 *state, double lambda)
Returns a Poissondistributed
unsigned int
using ThreeFry generator.Generates and returns Poissondistributed distributed random
unsigned int
values using ThreeFry generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_threefry2x64_20 *state, double lambda)
Returns a Poissondistributed
unsigned int
using ThreeFry generator.Generates and returns Poissondistributed distributed random
unsigned int
values using ThreeFry generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_threefry4x32_20 *state, double lambda)
Returns a Poissondistributed
unsigned int
using ThreeFry generator.Generates and returns Poissondistributed distributed random
unsigned int
values using ThreeFry generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS unsigned int rocrand_poisson (rocrand_state_threefry4x64_20 *state, double lambda)
Returns a Poissondistributed
unsigned int
using ThreeFry generator.Generates and returns Poissondistributed distributed random
unsigned int
values using ThreeFry generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
lambda –  Lambda parameter of the Poisson distribution
 Returns:
Poissondistributed
unsigned int
 FQUALIFIERS void rocrand_init (const unsigned int *vectors, const unsigned int scramble_constant, const unsigned int offset, rocrand_state_scrambled_sobol32 *state)
Initialize scrambled_sobol32 state.
Initializes the scrambled_sobol32 generator
state
with the given directionvectors
andoffset
. Parameters:
vectors –  Direction vectors
scramble_constant –  Constant used for scrambling the sequence
offset –  Absolute offset into sequence
state –  Pointer to state to initialize
 FQUALIFIERS unsigned int rocrand (rocrand_state_scrambled_sobol32 *state)
Returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range.Generates and returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range using scrambled_sobol32 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
 Returns:
Quasirandom value (32bit) as an
unsigned int
 FQUALIFIERS void skipahead (unsigned long long offset, rocrand_state_scrambled_sobol32 *state)
Updates SCRAMBLED_SOBOL32 state to skip ahead by
offset
elements.Updates the SCRAMBLED_SOBOL32 state in
state
to skip ahead byoffset
elements. Parameters:
offset –  Number of elements to skip
state –  Pointer to state to update
 FQUALIFIERS void rocrand_init (const unsigned long long int *vectors, const unsigned long long int scramble_constant, const unsigned int offset, rocrand_state_scrambled_sobol64 *state)
Initialize scrambled_sobol64 state.
Initializes the scrambled_sobol64 generator
state
with the given directionvectors
andoffset
. Parameters:
vectors –  Direction vectors
scramble_constant –  Constant used for scrambling the sequence
offset –  Absolute offset into sequence
state –  Pointer to state to initialize
 FQUALIFIERS unsigned long long int rocrand (rocrand_state_scrambled_sobol64 *state)
Returns uniformly distributed random
unsigned int
value from [0; 2^64  1] range.Generates and returns uniformly distributed random
unsigned int
value from [0; 2^64  1] range using scrambled_sobol64 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
 Returns:
Quasirandom value (64bit) as an
unsigned int
 FQUALIFIERS void skipahead (unsigned long long offset, rocrand_state_scrambled_sobol64 *state)
Updates scrambled_sobol64 state to skip ahead by
offset
elements.Updates the scrambled_sobol64 state in
state
to skip ahead byoffset
elements. Parameters:
offset –  Number of elements to skip
state –  Pointer to state to update
 FQUALIFIERS void rocrand_init (const unsigned int *vectors, const unsigned int offset, rocrand_state_sobol32 *state)
Initialize SOBOL32 state.
Initializes the SOBOL32 generator
state
with the given directionvectors
andoffset
. Parameters:
vectors –  Direction vectors
offset –  Absolute offset into sequence
state –  Pointer to state to initialize
 FQUALIFIERS unsigned int rocrand (rocrand_state_sobol32 *state)
Returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range.Generates and returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range using Sobol32 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
 Returns:
Quasirandom value (32bit) as an
unsigned int
 FQUALIFIERS void skipahead (unsigned long long offset, rocrand_state_sobol32 *state)
Updates SOBOL32 state to skip ahead by
offset
elements.Updates the SOBOL32 state in
state
to skip ahead byoffset
elements. Parameters:
offset –  Number of elements to skip
state –  Pointer to state to update
 FQUALIFIERS void rocrand_init (const unsigned long long int *vectors, const unsigned int offset, rocrand_state_sobol64 *state)
Initialize sobol64 state.
Initializes the sobol64 generator
state
with the given directionvectors
andoffset
. Parameters:
vectors –  Direction vectors
offset –  Absolute offset into sequence
state –  Pointer to state to initialize
 FQUALIFIERS unsigned long long int rocrand (rocrand_state_sobol64 *state)
Returns uniformly distributed random
unsigned int
value from [0; 2^64  1] range.Generates and returns uniformly distributed random
unsigned int
value from [0; 2^64  1] range using sobol64 generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
 Returns:
Quasirandom value (64bit) as an
unsigned int
 FQUALIFIERS void skipahead (unsigned long long int offset, rocrand_state_sobol64 *state)
Updates sobol64 state to skip ahead by
offset
elements.Updates the sobol64 state in
state
to skip ahead byoffset
elements. Parameters:
offset –  Number of elements to skip
state –  Pointer to state to update
 FQUALIFIERS float rocrand_uniform (rocrand_state_philox4x32_10 *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0f
, including1.0f
) using Philox generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS float2 rocrand_uniform2 (rocrand_state_philox4x32_10 *state)
Returns two uniformly distributed random
float
values from (0; 1] range.Generates and returns two uniformly distributed
float
values from (0; 1] range (excluding0.0f
, including1.0f
) using Philox generator instate
, and increments position of the generator by two. Parameters:
state –  Pointer to a state to use
 Returns:
Two uniformly distributed
float
values from (0; 1] range asfloat2
.
 FQUALIFIERS float4 rocrand_uniform4 (rocrand_state_philox4x32_10 *state)
Returns four uniformly distributed random
float
values from (0; 1] range.Generates and returns four uniformly distributed
float
values from (0; 1] range (excluding0.0f
, including1.0f
) using Philox generator instate
, and increments position of the generator by four. Parameters:
state –  Pointer to a state to use
 Returns:
Four uniformly distributed
float
values from (0; 1] range asfloat4
.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_philox4x32_10 *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using Philox generator instate
, and increments position of the generator by two. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS double2 rocrand_uniform_double2 (rocrand_state_philox4x32_10 *state)
Returns two uniformly distributed random
double
values from (0; 1] range.Generates and returns two uniformly distributed
double
values from (0; 1] range (excluding0.0
, including1.0
) using Philox generator instate
, and increments position of the generator by four. Parameters:
state –  Pointer to a state to use
 Returns:
Two uniformly distributed
double
values from (0; 1] range asdouble2
.
 FQUALIFIERS double4 rocrand_uniform_double4 (rocrand_state_philox4x32_10 *state)
Returns four uniformly distributed random
double
values from (0; 1] range.Generates and returns four uniformly distributed
double
values from (0; 1] range (excluding0.0
, including1.0
) using Philox generator instate
, and increments position of the generator by eight. Parameters:
state –  Pointer to a state to use
 Returns:
Four uniformly distributed
double
values from (0; 1] range asdouble4
.
 FQUALIFIERS float rocrand_uniform (rocrand_state_mrg31k3p *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0f
, including1.0f
) using MRG31K3P generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_mrg31k3p *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using MRG31K3P generator instate
, and increments position of the generator by one.Note: In this implementation returned
double
value is generated from only 32 random bits (oneunsigned int
value). Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_mrg32k3a *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0f
, including1.0f
) using MRG32K3A generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_mrg32k3a *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using MRG32K3A generator instate
, and increments position of the generator by one.Note: In this implementation returned
double
value is generated from only 32 random bits (oneunsigned int
value). Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_xorwow *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0f
, including1.0f
) using XORWOW generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_xorwow *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using MRG32K3A generator instate
, and increments position of the generator by two. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_mtgp32 *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0f
, including1.0f
) using MTGP32 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_mtgp32 *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using MTGP32 generator instate
, and increments position of the generator by one.Note: In this implementation returned
double
value is generated from only 32 random bits (oneunsigned int
value). Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_sobol32 *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0f
, including1.0f
) using SOBOL32 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_sobol32 *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using SOBOL32 generator instate
, and increments position of the generator by one.Note: In this implementation returned
double
value is generated from only 32 random bits (oneunsigned int
value). Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_scrambled_sobol32 *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0f
, including1.0f
) using SCRAMBLED_SOBOL32 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_scrambled_sobol32 *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using SCRAMBLED_SOBOL32 generator instate
, and increments position of the generator by one.Note: In this implementation returned
double
value is generated from only 32 random bits (oneunsigned int
value). Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_sobol64 *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0
, including1.0
) using SOBOL64 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_sobol64 *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using SOBOL64 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_scrambled_sobol64 *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0
, including1.0
) using SCRAMBLED_SOBOL64 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_scrambled_sobol64 *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using SCRAMBLED_SOBOL64 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_lfsr113 *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0f
, including1.0f
) using LFSR113 generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_lfsr113 *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using LFSR113 generator instate
, and increments position of the generator by one.Note: In this implementation returned
double
value is generated from only 32 random bits (oneunsigned int
value). Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_threefry2x32_20 *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0
, including1.0
) using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_threefry2x32_20 *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using ThreeFry generator instate
, and increments position of the generator by one.Note: In this implementation returned
double
value is generated from only 32 random bits (oneunsigned int
value). Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_threefry2x64_20 *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0
, including1.0
) using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_threefry2x64_20 *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using ThreeFry generator instate
, and increments position of the generator by one.Note: In this implementation returned
double
value is generated from only 32 random bits (oneunsigned int
value). Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_threefry4x32_20 *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0
, including1.0
) using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_threefry4x32_20 *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using ThreeFry generator instate
, and increments position of the generator by one.Note: In this implementation returned
double
value is generated from only 32 random bits (oneunsigned int
value). Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS float rocrand_uniform (rocrand_state_threefry4x64_20 *state)
Returns a uniformly distributed random
float
value from (0; 1] range.Generates and returns a uniformly distributed
float
value from (0; 1] range (excluding0.0
, including1.0
) using ThreeFry generator instate
, and increments position of the generator by one. Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
float
value from (0; 1] range.
 FQUALIFIERS double rocrand_uniform_double (rocrand_state_threefry4x64_20 *state)
Returns a uniformly distributed random
double
value from (0; 1] range.Generates and returns a uniformly distributed
double
value from (0; 1] range (excluding0.0
, including1.0
) using ThreeFry generator instate
, and increments position of the generator by one.Note: In this implementation returned
double
value is generated from only 32 random bits (oneunsigned int
value). Parameters:
state –  Pointer to a state to use
 Returns:
Uniformly distributed
double
value from (0; 1] range.
 FQUALIFIERS void rocrand_init (const unsigned long long seed, const unsigned long long subsequence, const unsigned long long offset, rocrand_state_xorwow *state)
Initialize XORWOW state.
Initializes the XORWOW generator
state
with the givenseed
,subsequence
, andoffset
. Parameters:
seed –  Value to use as a seed
subsequence –  Subsequence to start at
offset –  Absolute offset into subsequence
state –  Pointer to state to initialize
 FQUALIFIERS unsigned int rocrand (rocrand_state_xorwow *state)
Returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range.Generates and returns uniformly distributed random
unsigned int
value from [0; 2^32  1] range using XORWOW generator instate
. State is incremented by one position. Parameters:
state –  Pointer to a state to use
 Returns:
Pseudorandom value (32bit) as an
unsigned int
 FQUALIFIERS void skipahead (unsigned long long offset, rocrand_state_xorwow *state)
Updates XORWOW state to skip ahead by
offset
elements.Updates the XORWOW state in
state
to skip ahead byoffset
elements. Parameters:
offset –  Number of elements to skip
state –  Pointer to state to update
 FQUALIFIERS void skipahead_subsequence (unsigned long long subsequence, rocrand_state_xorwow *state)
Updates XORWOW state to skip ahead by
subsequence
subsequences.Updates the XORWOW
state
to skip ahead bysubsequence
subsequences. Each subsequence is 2^67 numbers long. Parameters:
subsequence –  Number of subsequences to skip
state –  Pointer to state to update
 FQUALIFIERS void skipahead_sequence (unsigned long long sequence, rocrand_state_xorwow *state)
Updates XORWOW state to skip ahead by
sequence
sequences.Updates the XORWOW
state
skippingsequence
sequences ahead. For XORWOW each sequence is 2^67 numbers long (equal to the size of a subsequence). Parameters:
sequence –  Number of sequences to skip
state –  Pointer to state to update

namespace rocrand_device#
Typedefs

typedef mtgp32_params_fast_t mtgp32_fast_params#
Functions

inline void rocrand_mtgp32_init_state(unsigned int array[], const mtgp32_fast_params *para, unsigned int seed)#
 template<class value> FQUALIFIERS int threefry_rotation_array (int index)
 template<> FQUALIFIERS int threefry_rotation_array< unsigned int > (int index)
 template<> FQUALIFIERS int threefry_rotation_array< unsigned long long > (int index)
 template<class value> FQUALIFIERS int threefry_rotation_array (int indexX, int indexY)
 template<> FQUALIFIERS int threefry_rotation_array< unsigned int > (int indexX, int indexY)
 template<> FQUALIFIERS int threefry_rotation_array< unsigned long long > (int indexX, int indexY)
 template<typename value> FQUALIFIERS value rotl (value x, int d)
 template<> FQUALIFIERS unsigned long long rotl< unsigned long long > (unsigned long long x, int d)
 template<> FQUALIFIERS unsigned int rotl< unsigned int > (unsigned int x, int d)
 template<typename value> FQUALIFIERS value skein_ks_parity ()
 template<> FQUALIFIERS unsigned int skein_ks_parity< unsigned int > ()
 template<> FQUALIFIERS unsigned long long skein_ks_parity< unsigned long long > ()

typedef mtgp32_params_fast_t mtgp32_fast_params#

ROCRAND_LFSR113_DEFAULT_SEED_X#
C Host API#
 group rocrandhost
Defines

ROCRAND_DEFAULT_MAX_BLOCK_SIZE#
The default maximum number of threads per block.
Typedefs

typedef enum rocrand_status rocrand_status
rocRAND function call status type

typedef enum rocrand_rng_type rocrand_rng_type
rocRAND generator type

typedef enum rocrand_ordering rocrand_ordering
rocRAND generator ordering

typedef enum rocrand_direction_vector_set rocrand_direction_vector_set
rocRAND vector set
Enums

enum rocrand_status#
rocRAND function call status type
Values:

enumerator ROCRAND_STATUS_SUCCESS#
No errors.

enumerator ROCRAND_STATUS_VERSION_MISMATCH#
Header file and linked library version do not match.

enumerator ROCRAND_STATUS_NOT_CREATED#
Generator was not created using rocrand_create_generator.

enumerator ROCRAND_STATUS_ALLOCATION_FAILED#
Memory allocation failed during execution.

enumerator ROCRAND_STATUS_TYPE_ERROR#
Generator type is wrong.

enumerator ROCRAND_STATUS_OUT_OF_RANGE#
Argument out of range.

enumerator ROCRAND_STATUS_LENGTH_NOT_MULTIPLE#
Requested size is not a multiple of quasirandom generator’s dimension, or requested size is not even (see rocrand_generate_normal()), or pointer is misaligned (see rocrand_generate_normal())

enumerator ROCRAND_STATUS_DOUBLE_PRECISION_REQUIRED#
GPU does not have double precision.

enumerator ROCRAND_STATUS_LAUNCH_FAILURE#
Kernel launch failure.

enumerator ROCRAND_STATUS_INTERNAL_ERROR#
Internal library error.

enumerator ROCRAND_STATUS_SUCCESS#

enum rocrand_rng_type#
rocRAND generator type
Values:

enumerator ROCRAND_RNG_PSEUDO_DEFAULT#
Default pseudorandom generator.

enumerator ROCRAND_RNG_PSEUDO_XORWOW#
XORWOW pseudorandom generator.

enumerator ROCRAND_RNG_PSEUDO_MRG32K3A#
MRG32k3a pseudorandom generator.

enumerator ROCRAND_RNG_PSEUDO_MTGP32#
Mersenne Twister MTGP32 pseudorandom generator.

enumerator ROCRAND_RNG_PSEUDO_PHILOX4_32_10#
PHILOX4x3210 pseudorandom generator.

enumerator ROCRAND_RNG_PSEUDO_MRG31K3P#
MRG31k3p pseudorandom generator.

enumerator ROCRAND_RNG_PSEUDO_LFSR113#
LFSR113 pseudorandom generator.

enumerator ROCRAND_RNG_PSEUDO_MT19937#
Mersenne Twister MT19937 pseudorandom generator.

enumerator ROCRAND_RNG_PSEUDO_THREEFRY2_32_20#
ThreeFry 32 bit state size 2 pseudorandom generator.

enumerator ROCRAND_RNG_PSEUDO_THREEFRY2_64_20#
ThreeFry 64 bit state size 2 pseudorandom generator.

enumerator ROCRAND_RNG_PSEUDO_THREEFRY4_32_20#
ThreeFry 32 bit state size 4 pseudorandom generator.

enumerator ROCRAND_RNG_PSEUDO_THREEFRY4_64_20#
ThreeFry 64 bit state size 4 pseudorandom generator.

enumerator ROCRAND_RNG_QUASI_DEFAULT#
Default quasirandom generator.

enumerator ROCRAND_RNG_QUASI_SOBOL32#
Sobol32 quasirandom generator.

enumerator ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL32#
Scrambled Sobol32 quasirandom generator.

enumerator ROCRAND_RNG_QUASI_SOBOL64#
Sobol64 quasirandom generator.

enumerator ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL64#
Scrambled Sobol64 quasirandom generator.

enumerator ROCRAND_RNG_PSEUDO_DEFAULT#

enum rocrand_ordering#
rocRAND generator ordering
Values:

enumerator ROCRAND_ORDERING_PSEUDO_BEST#
Best ordering for pseudorandom results.

enumerator ROCRAND_ORDERING_PSEUDO_DEFAULT#
Default ordering for pseudorandom results.

enumerator ROCRAND_ORDERING_PSEUDO_SEEDED#
Fast lower quality pseudorandom results.

enumerator ROCRAND_ORDERING_PSEUDO_LEGACY#
Legacy ordering for pseudorandom results.

enumerator ROCRAND_ORDERING_PSEUDO_DYNAMIC#
Adjust to the device executing the generator.

enumerator ROCRAND_ORDERING_QUASI_DEFAULT#
ndimensional ordering for quasirandom results

enumerator ROCRAND_ORDERING_PSEUDO_BEST#
Functions
 rocrand_status ROCRANDAPI rocrand_create_generator (rocrand_generator *generator, rocrand_rng_type rng_type)
Creates a new random number generator.
Creates a new pseudo random number generator of type
rng_type
and returns it ingenerator
.Values for
rng_type
are:ROCRAND_RNG_PSEUDO_XORWOW
ROCRAND_RNG_PSEUDO_MRG31K3P
ROCRAND_RNG_PSEUDO_MRG32K3A
ROCRAND_RNG_PSEUDO_MTGP32
ROCRAND_RNG_PSEUDO_PHILOX4_32_10
ROCRAND_RNG_PSEUDO_LFSR113
ROCRAND_RNG_PSEUDO_THREEFRY2_32_20
ROCRAND_RNG_PSEUDO_THREEFRY2_64_20
ROCRAND_RNG_PSEUDO_THREEFRY4_32_20
ROCRAND_RNG_PSEUDO_THREEFRY4_64_20
ROCRAND_RNG_QUASI_SOBOL32
ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL32
ROCRAND_RNG_QUASI_SOBOL64
ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL64
 Parameters:
generator –  Pointer to generator
rng_type –  Type of generator to create
 Returns:
ROCRAND_STATUS_ALLOCATION_FAILED, if memory could not be allocated
ROCRAND_STATUS_VERSION_MISMATCH if the header file version does not match the dynamically linked library version
ROCRAND_STATUS_TYPE_ERROR if the value for
rng_type
is invalidROCRAND_STATUS_SUCCESS if generator was created successfully
 rocrand_status ROCRANDAPI rocrand_destroy_generator (rocrand_generator generator)
Destroys random number generator.
Destroys random number generator and frees related memory.
 Parameters:
generator –  Generator to be destroyed
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_SUCCESS if generator was destroyed successfully
 rocrand_status ROCRANDAPI rocrand_generate (rocrand_generator generator, unsigned int *output_data, size_t n)
Generates uniformly distributed 32bit unsigned integers.
Generates
n
uniformly distributed 32bit unsigned integers and saves them tooutput_data
.Generated numbers are between
0
and2^32
, including0
and excluding2^32
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of 32bit unsigned integers to generate
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_long_long (rocrand_generator generator, unsigned long long int *output_data, size_t n)
Generates uniformly distributed 64bit unsigned integers.
Generates
n
uniformly distributed 64bit unsigned integers and saves them tooutput_data
.Generated numbers are between
0
and2^64
, including0
and excluding2^64
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of 64bit unsigned integers to generate
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_TYPE_ERROR if the generator can’t natively generate 64bit random numbers
ROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_char (rocrand_generator generator, unsigned char *output_data, size_t n)
Generates uniformly distributed 8bit unsigned integers.
Generates
n
uniformly distributed 8bit unsigned integers and saves them tooutput_data
.Generated numbers are between
0
and2^8
, including0
and excluding2^8
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of 8bit unsigned integers to generate
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_short (rocrand_generator generator, unsigned short *output_data, size_t n)
Generates uniformly distributed 16bit unsigned integers.
Generates
n
uniformly distributed 16bit unsigned integers and saves them tooutput_data
.Generated numbers are between
0
and2^16
, including0
and excluding2^16
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of 16bit unsigned integers to generate
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_uniform (rocrand_generator generator, float *output_data, size_t n)
Generates uniformly distributed
float
values.Generates
n
uniformly distributed 32bit floatingpoint values and saves them tooutput_data
.Generated numbers are between
0.0f
and1.0f
, excluding0.0f
and including1.0f
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of
float
s to generate
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_uniform_double (rocrand_generator generator, double *output_data, size_t n)
Generates uniformly distributed doubleprecision floatingpoint values.
Generates
n
uniformly distributed 64bit doubleprecision floatingpoint values and saves them tooutput_data
.Generated numbers are between
0.0
and1.0
, excluding0.0
and including1.0
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of
double
s to generate
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_uniform_half (rocrand_generator generator, half *output_data, size_t n)
Generates uniformly distributed halfprecision floatingpoint values.
Generates
n
uniformly distributed 16bit halfprecision floatingpoint values and saves them tooutput_data
.Generated numbers are between
0.0
and1.0
, excluding0.0
and including1.0
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of
half
s to generate
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_normal (rocrand_generator generator, float *output_data, size_t n, float mean, float stddev)
Generates normally distributed
float
values.Generates
n
normally distributed distributed 32bit floatingpoint values and saves them tooutput_data
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of
float
s to generatemean –  Mean value of normal distribution
stddev –  Standard deviation value of normal distribution
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_normal_double (rocrand_generator generator, double *output_data, size_t n, double mean, double stddev)
Generates normally distributed
double
values.Generates
n
normally distributed 64bit doubleprecision floatingpoint numbers and saves them tooutput_data
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of
double
s to generatemean –  Mean value of normal distribution
stddev –  Standard deviation value of normal distribution
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_normal_half (rocrand_generator generator, half *output_data, size_t n, half mean, half stddev)
Generates normally distributed
half
values.Generates
n
normally distributed 16bit halfprecision floatingpoint numbers and saves them tooutput_data
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of
half
s to generatemean –  Mean value of normal distribution
stddev –  Standard deviation value of normal distribution
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_log_normal (rocrand_generator generator, float *output_data, size_t n, float mean, float stddev)
Generates lognormally distributed
float
values.Generates
n
lognormally distributed 32bit floatingpoint values and saves them tooutput_data
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of
float
s to generatemean –  Mean value of log normal distribution
stddev –  Standard deviation value of log normal distribution
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_log_normal_double (rocrand_generator generator, double *output_data, size_t n, double mean, double stddev)
Generates lognormally distributed
double
values.Generates
n
lognormally distributed 64bit doubleprecision floatingpoint values and saves them tooutput_data
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of
double
s to generatemean –  Mean value of log normal distribution
stddev –  Standard deviation value of log normal distribution
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_log_normal_half (rocrand_generator generator, half *output_data, size_t n, half mean, half stddev)
Generates lognormally distributed
half
values.Generates
n
lognormally distributed 16bit halfprecision floatingpoint values and saves them tooutput_data
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of
half
s to generatemean –  Mean value of log normal distribution
stddev –  Standard deviation value of log normal distribution
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_generate_poisson (rocrand_generator generator, unsigned int *output_data, size_t n, double lambda)
Generates Poissondistributed 32bit unsigned integers.
Generates
n
Poissondistributed 32bit unsigned integers and saves them tooutput_data
. Parameters:
generator –  Generator to use
output_data –  Pointer to memory to store generated numbers
n –  Number of 32bit unsigned integers to generate
lambda –  lambda for the Poisson distribution
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_OUT_OF_RANGE if lambda is nonpositive
ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if
n
is not a multiple of the dimension of used quasirandom generatorROCRAND_STATUS_SUCCESS if random numbers were successfully generated
 rocrand_status ROCRANDAPI rocrand_initialize_generator (rocrand_generator generator)
Initializes the generator’s state on GPU or host.
Initializes the generator’s state on GPU or host. User it not required to call this function before using a generator.
If rocrand_initialize() was not called for a generator, it will be automatically called by functions which generates random numbers like rocrand_generate(), rocrand_generate_uniform() etc.
 Parameters:
generator –  Generator to initialize
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed
ROCRAND_STATUS_SUCCESS if the seeds were generated successfully
 rocrand_status ROCRANDAPI rocrand_set_stream (rocrand_generator generator, hipStream_t stream)
Sets the current stream for kernel launches.
Sets the current stream for all kernel launches of the generator. All functions will use this stream.
 Parameters:
generator –  Generator to modify
stream –  Stream to use or NULL for default stream
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_SUCCESS if stream was set successfully
 rocrand_status ROCRANDAPI rocrand_set_seed (rocrand_generator generator, unsigned long long seed)
Sets the seed of a pseudorandom number generator.
Sets the seed of the pseudorandom number generator.
This operation resets the generator’s internal state.
This operation does not change the generator’s offset.
For an MRG32K3a or MRG31K3p generator the seed value can’t be zero. If
seed
is equal to zero and generator’s type is ROCRAND_RNG_PSEUDO_MRG32K3A or ROCRAND_RNG_PSEUDO_MRG31K3P, value12345
is used as seed instead.For a LFSR113 generator seed values must be larger than 1, 7, 15,
The
seed
upper and lower 32 bits used as first and second seed value. If those values smaller than 2 and/or 8, those are increased with 1 and/or 7.
 Parameters:
generator –  Pseudorandom number generator
seed –  New seed value
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_TYPE_ERROR if the generator is a quasirandom number generator
ROCRAND_STATUS_SUCCESS if seed was set successfully
 rocrand_status ROCRANDAPI rocrand_set_seed_uint4 (rocrand_generator generator, uint4 seed)
Sets the seeds of a pseudorandom number generator.
Sets the seed of the pseudorandom number generator. Currently only for LFSR113
This operation resets the generator’s internal state.
This operation does not change the generator’s offset.
Only usable for LFSR113.
For a LFSR113 generator seed values must be bigger than 1, 7, 15,
If those values smaller, than the requested minimum values [2, 8, 16, 128], then it will be increased with the minimum values minus 1 [1, 7, 15, 127].
 Parameters:
generator –  Pseudorandom number generator
seed –  New seed value
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_TYPE_ERROR if the generator is a quasirandom number generator
ROCRAND_STATUS_SUCCESS if seed was set successfully
 rocrand_status ROCRANDAPI rocrand_set_offset (rocrand_generator generator, unsigned long long offset)
Sets the offset of a random number generator.
Sets the absolute offset of the random number generator.
This operation resets the generator’s internal state.
This operation does not change the generator’s seed.
Absolute offset cannot be set if generator’s type is ROCRAND_RNG_PSEUDO_MTGP32 or ROCRAND_RNG_PSEUDO_LFSR113.
 Parameters:
generator –  Random number generator
offset –  New absolute offset
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_SUCCESS if offset was successfully set
ROCRAND_STATUS_TYPE_ERROR if generator’s type is ROCRAND_RNG_PSEUDO_MTGP32 or ROCRAND_RNG_PSEUDO_LFSR113
 rocrand_status ROCRANDAPI rocrand_set_ordering (rocrand_generator generator, rocrand_ordering order)
Sets the ordering of a random number generator.
Sets the ordering of the results of a random number generator.
This operation resets the generator’s internal state.
This operation does not change the generator’s seed.
The ordering choices for pseudorandom sequences are ROCRAND_ORDERING_PSEUDO_DEFAULT and ROCRAND_ORDERING_PSEUDO_LEGACY. The default ordering is ROCRAND_ORDERING_PSEUDO_DEFAULT, which is equal to ROCRAND_ORDERING_PSEUDO_LEGACY for now.
For quasirandom sequences there is only one ordering, ROCRAND_ORDERING_QUASI_DEFAULT.
 Parameters:
generator –  Random number generator
order –  New ordering of results
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_OUT_OF_RANGE if the ordering is not valid
ROCRAND_STATUS_SUCCESS if the ordering was successfully set
ROCRAND_STATUS_TYPE_ERROR if generator’s type is not valid
 rocrand_status ROCRANDAPI rocrand_set_quasi_random_generator_dimensions (rocrand_generator generator, unsigned int dimensions)
Set the number of dimensions of a quasirandom number generator.
Set the number of dimensions of a quasirandom number generator. Supported values of
dimensions
are 1 to 20000.This operation resets the generator’s internal state.
This operation does not change the generator’s offset.
 Parameters:
generator –  Quasirandom number generator
dimensions –  Number of dimensions
 Returns:
ROCRAND_STATUS_NOT_CREATED if the generator wasn’t created
ROCRAND_STATUS_TYPE_ERROR if the generator is not a quasirandom number generator
ROCRAND_STATUS_OUT_OF_RANGE if
dimensions
is out of rangeROCRAND_STATUS_SUCCESS if the number of dimensions was set successfully
 rocrand_status ROCRANDAPI rocrand_get_version (int *version)
Returns the version number of the library.
Returns in
version
the version number of the dynamically linked rocRAND library. Parameters:
version –  Version of the library
 Returns:
ROCRAND_STATUS_OUT_OF_RANGE if
version
is NULLROCRAND_STATUS_SUCCESS if the version number was successfully returned
 rocrand_status ROCRANDAPI rocrand_create_poisson_distribution (double lambda, rocrand_discrete_distribution *discrete_distribution)
Construct the histogram for a Poisson distribution.
Construct the histogram for the Poisson distribution with lambda
lambda
. Parameters:
lambda –  lambda for the Poisson distribution
discrete_distribution –  pointer to the histogram in device memory
 Returns:
ROCRAND_STATUS_ALLOCATION_FAILED if memory could not be allocated
ROCRAND_STATUS_OUT_OF_RANGE if
discrete_distribution
pointer was nullROCRAND_STATUS_OUT_OF_RANGE if lambda is nonpositive
ROCRAND_STATUS_SUCCESS if the histogram was constructed successfully
 rocrand_status ROCRANDAPI rocrand_create_discrete_distribution (const double *probabilities, unsigned int size, unsigned int offset, rocrand_discrete_distribution *discrete_distribution)
Construct the histogram for a custom discrete distribution.
Construct the histogram for the discrete distribution of
size
32bit unsigned integers from the range [offset
,offset
+size
) usingprobabilities
as probabilities. Parameters:
probabilities –  probabilities of the the distribution in host memory
size –  size of
probabilities
offset –  offset of values
discrete_distribution –  pointer to the histogram in device memory
 Returns:
ROCRAND_STATUS_ALLOCATION_FAILED if memory could not be allocated
ROCRAND_STATUS_OUT_OF_RANGE if
discrete_distribution
pointer was nullROCRAND_STATUS_OUT_OF_RANGE if
size
was zeroROCRAND_STATUS_SUCCESS if the histogram was constructed successfully
 rocrand_status ROCRANDAPI rocrand_destroy_discrete_distribution (rocrand_discrete_distribution discrete_distribution)
Destroy the histogram array for a discrete distribution.
Destroy the histogram array for a discrete distribution created by rocrand_create_poisson_distribution.
 Parameters:
discrete_distribution –  pointer to the histogram in device memory
 Returns:
ROCRAND_STATUS_OUT_OF_RANGE if
discrete_distribution
was nullROCRAND_STATUS_SUCCESS if the histogram was destroyed successfully
 rocrand_status ROCRANDAPI rocrand_get_direction_vectors32 (const unsigned int **vectors, rocrand_direction_vector_set set)
Get the vector for 32bit (scrambled)sobol generation.
 Parameters:
vectors –  location where to write the vector pointer to
set –  which direction vector set to use
 Returns:
ROCRAND_STATUS_OUT_OF_RANGE if
set
was invalid for this methodROCRAND_STATUS_SUCCESS if the pointer was set succesfully
 rocrand_status ROCRANDAPI rocrand_get_direction_vectors64 (const unsigned long long **vectors, rocrand_direction_vector_set set)
Get the vector for 64bit (scrambled)sobol generation.
 Parameters:
vectors –  location where to write the vector pointer to
set –  which direction vector set to use
 Returns:
ROCRAND_STATUS_OUT_OF_RANGE if
set
was invalid for this methodROCRAND_STATUS_SUCCESS if the pointer was set succesfully
 rocrand_status ROCRANDAPI rocrand_get_scramble_constants32 (const unsigned int **constants)
Get the scramble constants for 32bit scrambled sobol generation.
 Parameters:
constants –  location where to write the constants pointer to
 Returns:
ROCRAND_STATUS_SUCCESS if the pointer was set succesfully
 rocrand_status ROCRANDAPI rocrand_get_scramble_constants64 (const unsigned long long **constants)
Get the scramble constants for 64bit scrambled sobol generation.
 Parameters:
constants –  location where to write the constants pointer to
 Returns:
ROCRAND_STATUS_SUCCESS if the pointer was set succesfully

ROCRAND_DEFAULT_MAX_BLOCK_SIZE#
C++ Host API Wrapper#
 group rocrandhostcpp
Typedefs

typedef philox4x32_10_engine philox4x32_10#
Typedef of rocrand_cpp::philox4x32_10_engine PRNG engine with default seed (ROCRAND_PHILOX4x32_DEFAULT_SEED).

typedef xorwow_engine xorwow#
Typedef of
rocrand_cpp::xorwow_engine
PRNG engine with default seed (ROCRAND_XORWOW_DEFAULT_SEED).

typedef mrg31k3p_engine mrg31k3p#
Typedef of
rocrand_cpp::mrg31k3p_engine
PRNG engine with default seed (ROCRAND_MRG31K3P_DEFAULT_SEED).

typedef mrg32k3a_engine mrg32k3a#
Typedef of
rocrand_cpp::mrg32k3a_engine
PRNG engine with default seed (ROCRAND_MRG32K3A_DEFAULT_SEED).

typedef mtgp32_engine mtgp32#
Typedef of
rocrand_cpp::mtgp32_engine
PRNG engine with default seed (0).

typedef lfsr113_engine lfsr113#
Typedef of
rocrand_cpp::lfsr113_engine
PRNG engine with default seed (ROCRAND_LFSR113_DEFAULT_SEED_X, ROCRAND_LFSR113_DEFAULT_SEED_Y, ROCRAND_LFSR113_DEFAULT_SEED_Z, ROCRAND_LFSR113_DEFAULT_SEED_W).

typedef mt19937_engine mt19937#
Typedef of
rocrand_cpp::mt19937_engine
PRNG engine with default seed (0).

typedef threefry2x32_20_engine threefry2x32#
Typedef of
rocrand_cpp::threefry2x32_20_engine
PRNG engine with default seed (0).

typedef threefry2x64_20_engine threefry2x64#
Typedef of
rocrand_cpp::threefry2x64_20_engine
PRNG engine with default seed (0).

typedef threefry4x32_20_engine threefry4x32#
Typedef of
rocrand_cpp::threefry4x32_20_engine
PRNG engine with default seed (0).

typedef threefry4x64_20_engine threefry4x64#
Typedef of
rocrand_cpp::threefry4x64_20_engine
PRNG engine with default seed (0).

typedef sobol32_engine sobol32#
Typedef of
rocrand_cpp::sobol32_engine
QRNG engine with default number of dimensions (1).

typedef scrambled_sobol32_engine scrambled_sobol32#
Typedef of
rocrand_cpp::scrambled_sobol32_engine
QRNG engine with default number of dimensions (1).

typedef sobol64_engine sobol64#
Typedef of
rocrand_cpp::sobol64_engine
QRNG engine with default number of dimensions (1).

typedef scrambled_sobol64_engine scrambled_sobol64#
Typedef of
rocrand_cpp::scrambled_sobol64_engine
QRNG engine with default number of dimensions (1).

typedef std::random_device random_device#
A nondeterministic uniform random number generator.
rocrand_cpp::random_device is nondeterministic uniform random number generator, or a pseudorandom number engine if there is no support for nondeterministic random number generation. It’s implemented as a typedef of std::random_device.
For practical use rocrand_cpp::random_device is generally only used to seed a PRNG such as rocrand_cpp::mtgp32_engine.
Example:
#include <rocrand/rocrand.hpp> int main() { const size_t size = 8192; unsigned int * output; hipMalloc(&output, size * sizeof(unsigned int)); rocrand_cpp::random_device rd; rocrand_cpp::mtgp32 engine(rd()); // seed engine with a real random value, if available rocrand_cpp::normal_distribution<float> dist(0.0, 1.5); dist(engine, output, size); }
Functions

inline int version()#
Returns rocRAND version.
 Returns:
rocRAND version number as an
int
value.

class error : public exception#
 #include <rocrand.hpp>
A runtime rocRAND error.
The error class represents an error returned by a rocRAND function.

template<class IntType = unsigned int>
class uniform_int_distribution#  #include <rocrand.hpp>
Produces random integer values uniformly distributed on the interval [0, 2^(sizeof(IntType)*8)  1].
 Template Parameters:
IntType –  type of generated values. Only
unsigned
char
,unsigned
short
andunsigned
int
andunsigned
long
long
int
type is supported.

template<class RealType = float>
class uniform_real_distribution#  #include <rocrand.hpp>
Produces random floatingpoint values uniformly distributed on the interval (0, 1].
 Template Parameters:
RealType –  type of generated values. Only
float
,double
andhalf
types are supported.

template<class RealType = float>
class normal_distribution#  #include <rocrand.hpp>
Produces random numbers according to a normal distribution.
 Template Parameters:
RealType –  type of generated values. Only
float
,double
andhalf
types are supported.

template<class RealType = float>
class lognormal_distribution#  #include <rocrand.hpp>
Produces positive random numbers according to a lognormal distribution.
 Template Parameters:
RealType –  type of generated values. Only
float
,double
andhalf
types are supported.

template<class IntType = unsigned int>
class poisson_distribution#  #include <rocrand.hpp>
Produces random nonnegative integer values distributed according to Poisson distribution.
 Template Parameters:
IntType –  type of generated values. Only
unsinged
int
type is supported.

template<unsigned long long DefaultSeed = ROCRAND_PHILOX4x32_DEFAULT_SEED>
class philox4x32_10_engine#  #include <rocrand.hpp>
Pseudorandom number engine based Philox algorithm.
It generates random numbers of type
unsigned
int
on the interval [0; 2^32  1]. Random numbers are generated in sets of four.

template<unsigned long long DefaultSeed = ROCRAND_XORWOW_DEFAULT_SEED>
class xorwow_engine#  #include <rocrand.hpp>
Pseudorandom number engine based XORWOW algorithm.
xorwow_engine is a xorshift pseudorandom number engine based on XORWOW algorithm. It produces random numbers of type
unsigned
int
on the interval [0; 2^32  1].

template<unsigned long long DefaultSeed = ROCRAND_MRG31K3P_DEFAULT_SEED>
class mrg31k3p_engine#  #include <rocrand.hpp>
Pseudorandom number engine based MRG31k3p CMRG.
mrg31k3p_engine is an implementation of MRG31k3p pseudorandom number generator, which is a Combined Multiple Recursive Generator (CMRG) created by Pierre L’Ecuyer. It produces random 32bit
unsigned
int
values on the interval [0; 2^32  1].

template<unsigned long long DefaultSeed = ROCRAND_MRG32K3A_DEFAULT_SEED>
class mrg32k3a_engine#  #include <rocrand.hpp>
Pseudorandom number engine based MRG32k3a CMRG.
mrg32k3a_engine is an implementation of MRG32k3a pseudorandom number generator, which is a Combined Multiple Recursive Generator (CMRG) created by Pierre L’Ecuyer. It produces random 32bit
unsigned
int
values on the interval [0; 2^32  1].

template<unsigned long long DefaultSeed = 0>
class mtgp32_engine#  #include <rocrand.hpp>
Random number engine based on the Mersenne Twister for Graphic Processors algorithm.
mtgp32_engine is a random number engine based on the Mersenne Twister for Graphic Processors algorithm, which is a version of wellknown Mersenne Twister algorithm. It produces high quality random numbers of type
unsigned
int
on the interval [0; 2^32  1].

template<unsigned int DefaultSeedX = ROCRAND_LFSR113_DEFAULT_SEED_X, unsigned int DefaultSeedY = ROCRAND_LFSR113_DEFAULT_SEED_Y, unsigned int DefaultSeedZ = ROCRAND_LFSR113_DEFAULT_SEED_Z, unsigned int DefaultSeedW = ROCRAND_LFSR113_DEFAULT_SEED_W>
class lfsr113_engine#  #include <rocrand.hpp>
Random number engine based on the LFSR113 algorithm.
lfsr113_engine is an implementation of LFSR113 pseudorandom number generator, which is a linear feedback shift resgisters (LFSR) based generator created by Pierre L’Ecuyer. It produces random 32bit
unsigned
int
values on the interval [0; 2^32  1].

template<unsigned long long DefaultSeed = 0ULL>
class mt19937_engine#  #include <rocrand.hpp>
Random number engine based on the Mersenne Twister algorithm.
mt19937 is a random number engine based on the Mersenne Twister algorithm as proposed in “Mersenne Twister: A 623Dimensionally Equidistributed Uniform
PseudoRandom Number Generator”. It produces high quality random numbers of type
unsigned
int
on the interval [0; 2^32  1].

template<unsigned int DefaultNumDimensions = 1>
class sobol32_engine#  #include <rocrand.hpp>
Sobol’s quasirandom sequence generator.
sobol32_engine is quasirandom number engine which produced Sobol sequences. This implementation supports generating sequences in up to 20,000 dimensions. The engine produces random unsigned integers on the interval [0, 2^32  1].

template<unsigned int DefaultNumDimensions = 1>
class scrambled_sobol32_engine#  #include <rocrand.hpp>
Sobol’s scrambled quasirandom sequence generator.
scrambled_sobol32_engine is a quasirandom number engine which produces scrambled Sobol sequences. This implementation supports generating sequences in up to 20,000 dimensions. The engine produces random unsigned integers on the interval [0, 2^32  1].

template<unsigned int DefaultNumDimensions = 1>
class sobol64_engine#  #include <rocrand.hpp>
Sobol’s quasirandom sequence generator.
sobol64 is a quasirandom number engine which produces Sobol sequences. This implementation supports generating sequences in up to 20,000 dimensions. The engine produces random unsigned integers on the interval [0, 2^64  1].

template<unsigned int DefaultNumDimensions = 1>
class scrambled_sobol64_engine#  #include <rocrand.hpp>
Sobol’s scrambled quasirandom sequence generator.
scrambled_sobol64_engine is a quasirandom number engine which produces scrambled Sobol sequences. This implementation supports generating sequences in up to 20,000 dimensions. The engine produces random unsigned long long integers on the interval [0, 2^64  1].

template<unsigned long long DefaultSeed = 0>
class threefry2x32_20_engine#  #include <rocrand.hpp>
Pseudorandom number engine based on 2 state ThreeFry.
It generates random numbers of type
unsigned
int
on the interval [0; 2^32  1]. Random numbers are generated in sets of two.

template<unsigned long long DefaultSeed = 0>
class threefry2x64_20_engine#  #include <rocrand.hpp>
Pseudorandom number engine based 2 state ThreeFry.
It generates random numbers of type
unsigned
int
on the interval [0; 2^62  1]. Random numbers are generated in sets of two.

template<unsigned long long DefaultSeed = 0>
class threefry4x32_20_engine#  #include <rocrand.hpp>
Pseudorandom number engine based on 2 state ThreeFry.
It generates random numbers of type
unsigned
int
on the interval [0; 2^32  1]. Random numbers are generated in sets of two.

template<unsigned long long DefaultSeed = 0>
class threefry4x64_20_engine#  #include <rocrand.hpp>
Pseudorandom number engine based 2 state ThreeFry.
It generates random numbers of type
unsigned
int
on the interval [0; 2^62  1]. Random numbers are generated in sets of two.

typedef philox4x32_10_engine philox4x32_10#