rocRAND

https://rocm.docs.amd.com/projects/rocRAND/en/latest/
Admin
rocRAND is a pseudo-random and quasi-random number generation library implemented in HIP and...
Tokens:405,768
Snippets:3,363
Trust Score:10
Update:5 months ago
Show doc for...
Tokens:
Raw
### Build rocRAND using install script

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

Navigate to the rocRAND project directory and use the install script to build the library. This script handles dependencies and installs to /opt/rocm.

```bash
cd rocm-libraries/projects/rocrand
./install --install

```

--------------------------------

### Install Requirements for Configuration Tuning

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/conceptual/dynamic_ordering_configuration.html

Installs the necessary Python packages for the configuration tuning scripts. Ensure you are in the correct directory before running.

```bash
pip install -r rocm-libraries/projects/rocrand/scripts/config-tuning/requirements.txt.
```

--------------------------------

### Install Python API Wrapper for rocRAND

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

Navigate to the Python wrapper directory and use `pip` to install the rocRAND Python module. Ensure rocRAND is built and accessible via the `ROCRAND_PATH` environment variable if not installed in a standard location.

```bash
cd rocm-libraries/projects/rocrand/python/rocrand
pip install .
```

--------------------------------

### Install rocRAND with HIP on Windows

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

Clone the rocm-libraries repository and use the `rmake.py` script to install and build rocRAND with HIP support on Windows. The `-i` option installs by default to `C:\hipSDK`, and `-c` builds all clients including unit tests.

```bash
git clone https://github.com/ROCm/rocm-libraries.git
cd rocm-libraries/projects/rocrand
python rmake.py -i
```

```bash
python rmake.py -c
```

--------------------------------

### C++ Host API Wrapper Example

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/cpp-api.html

An example demonstrating the usage of the C++ host API wrapper to generate a random number using the default generation parameters.

```APIDOC
## C++ Host API Wrapper Example

### Description
This example demonstrates how to use the C++ host API wrapper to produce a random number using the default generation parameters.

### Code
```cpp
#include <hip/hip_runtime.h>
#include <rocrand/rocrand.hpp>

#include <iostream>

int main()
{
    float* d_rand;
    float  h_rand;
    hipMalloc((void**)&d_rand, sizeof(float));

    rocrand_cpp::xorwow                gen;
    rocrand_cpp::normal_distribution<> dist;

    dist(gen, d_rand, 1);

    hipMemcpy(&h_rand, d_rand, sizeof(float), hipMemcpyDeviceToHost);

    std::cout << h_rand << std::endl;

    hipFree(d_rand);

    return 0;
}
```
```

--------------------------------

### Install rocRAND on Ubuntu/Debian

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

Use this command to install rocRAND from ROCm repositories on Ubuntu and Debian-based systems.

```bash
sudo apt-get install rocrand

```

--------------------------------

### Using XORWOW Generator in a Device Kernel

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/cpp-api.html

This example demonstrates how to use the XORWOW generator within a device kernel. Include `rocrand_kernel.h`, create and initialize a `rocrand_state_xorwow` object, and then call `rocrand` to generate numbers.

```cpp
#include <hip/hip_runtime.h>
#include <rocrand/rocrand_kernel.h>

__global__
void test()
{
    uint                 tid = blockDim.x * blockIdx.x + threadIdx.x;
    rocrand_state_xorwow state;
    rocrand_init(123, tid, 0, &state);

    for(int i = 0; i < 3; ++i)
    {
        const auto value = rocrand(&state);
        printf("thread %d, index %u: %u\n", tid, i, value);
    }
}

int main()
{
    test<<<dim3(1), dim3(32)>>>();
    hipDeviceSynchronize();
}
```

--------------------------------

### Capture rocRAND Operations in HIP Graph

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/conceptual/programmers-guide.html

This example demonstrates capturing rocRAND operations within a HIP Graph. Generator initialization, stream creation, and graph setup must be done before capture, and cleanup after launch. Error handling is omitted for brevity.

```c++
size_t        size = 1000;
float*        data_0;
unsigned int* data_1;

ipMalloc(&data_0, sizeof(*data_0) * size);
ipMalloc(&data_1, sizeof(*data_1) * size);

ipGraph_t graph;
ipGraphCreate(&graph, 0);

ipStream_t stream;
ipStreamCreateWithFlags(&stream, hipStreamNonBlocking);

rocrand_generator generator;
ocrand_create_generator(&generator, ROCRAND_RNG_PSEUDO_DEFAULT);
ocrand_set_stream(generator, stream);
ocrand_initialize_generator(generator);

ipStreamBeginCapture(stream, hipStreamCaptureModeGlobal);

ocrand_generate_normal(generator, data_0, size, 10.0F, 2.0F);
ocrand_generate_poisson(generator, data_1, size, 3);

ipStreamEndCapture(stream, &graph);

ipGraphExec_t instance;
ipGraphInstantiate(&instance, graph, nullptr, nullptr, 0);

ipGraphLaunch(instance, stream);
ipStreamSynchronize(stream);

ipGraphExecDestroy(instance);
ocrand_destroy_generator(generator);
ipStreamDestroy(stream);
ipGraphDestroy(graph);
ipFree(data_1);
ipFree(data_0);

```

--------------------------------

### Example Usage of rocrand_mtgp32_block_copy

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/cpp-api.html

Demonstrates how to use `rocrand_mtgp32_block_copy` within a CUDA kernel to manage and copy generator states between global and shared memory.

```cpp
__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]);
}

```

--------------------------------

### Install rocRAND on CentOS

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

Use this command to install rocRAND from ROCm repositories on CentOS-based systems.

```bash
sudo yum install rocrand

```

--------------------------------

### Configure rocRAND build with CMake

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

Manually configure the rocRAND build using CMake for more detailed installation options. Specify the C++ compiler using CXX.

```bash
cd rocm-libraries/projects/rocrand; mkdir build; cd build
# Configure the project
CXX=<compiler> cmake [options] ..

```

--------------------------------

### Execute rocRAND Python API Tests

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

After installing the Python API wrapper, navigate to the tests directory and run the `rocrand_test.py` script to execute the tests.

```bash
cd rocm-libraries/projects/rocrand/python/rocrand
python tests/rocrand_test.py
```

--------------------------------

### Generate Random Floats on GPU using C Host API

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/cpp-api.html

This example demonstrates generating ten random floats on the GPU using the ROCRAND C host API. It includes steps for memory allocation on both host and device, generator creation, setting a seed, generating numbers, copying results to host, printing, and cleanup.

```c
#include <hip/hip_runtime.h>
#include <rocrand.h>
#include <stdio.h>

int main()
{
    size_t n = 10;

    rocrand_generator gen;
    float *           d_rand, *h_rand;

    h_rand = (float*)malloc(sizeof(float) * n);
    hipMalloc((void**)&d_rand, n * sizeof(float));

    rocrand_create_generator(&gen, ROCRAND_RNG_PSEUDO_DEFAULT);
    rocrand_set_seed(gen, 123);
    rocrand_generate_uniform(gen, d_rand, n);

    hipMemcpy(h_rand, d_rand, n * sizeof(float), hipMemcpyDeviceToHost);

    for(int i = 0; i < n; i++)
    {
        printf("%f\n", h_rand[i]);
    }

    rocrand_destroy_generator(gen);
    hipFree(d_rand);

    return 0;
}

```

--------------------------------

### Generate Uniform Random Values in Fortran

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/fortran-api-reference.html

Example Fortran program demonstrating the generation of uniform random values using rocRAND Host API functions. This involves allocating device memory, creating a generator, generating values, copying them to the host, and freeing resources.

```fortran
integer(kind =8) :: gen
real, target, dimension(128) :: h_x
type(c_ptr) :: d_x
integer(c_int) :: status
integer(c_size_t), parameter :: output_size = 128
status = hipMalloc(d_x, output_size * sizeof(h_x(1)))
status = rocrand_create_generator(gen, ROCRAND_RNG_PSEUDO_DEFAULT)
status = rocrand_generate_uniform(gen, d_x, output_size)
status = hipMemcpy(c_loc(h_x), d_x, output_size * sizeof(h_x(1)), hipMemcpyDeviceToHost)
status = hipFree(d_x)
status = rocrand_destroy_generator(gen)
```

--------------------------------

### Install rocRAND on SLES

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

Use this command to install rocRAND from ROCm repositories on SLES systems.

```bash
sudo dnf install rocrand

```

--------------------------------

### Constructor

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/classrocrand__cpp_1_1sobol64__engine-members.html

Constructs a sobol64_engine with specified dimensions, offset, and ordering. Defaults can be used if not provided.

```APIDOC
## rocrand_cpp::sobol64_engine(dimensions_num_type num_of_dimensions = DefaultNumDimensions, offset_type offset_value = 0, order_type order_value = ROCRAND_ORDERING_QUASI_DEFAULT)

### Description
Constructs a Sobol' 64-bit quasi-random number generator engine. Allows customization of the number of dimensions, the offset for the sequence, and the ordering of generated numbers. Default values are used if not specified.

### Parameters
* **num_of_dimensions** (dimensions_num_type) - Optional - The number of dimensions for the Sobol' sequence. Defaults to `DefaultNumDimensions`.
* **offset_value** (offset_type) - Optional - The starting offset for the quasi-random sequence. Defaults to 0.
* **order_value** (order_type) - Optional - The ordering of the generated quasi-random numbers. Defaults to `ROCRAND_ORDERING_QUASI_DEFAULT`.
```

--------------------------------

### Create and Copy Device Array with rocrand

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/python-api.html

Demonstrates creating a device-side array using `rocrand.empty`, filling it with uniform random numbers using a QRNG generator, and then copying the data back to the host using `copy_to_host`. Ensure `numpy` is imported as `np`.

```python
import rocrand
import numpy as np

gen = rocrand.QRNG(ndim=5)
d_a = rocrand.empty((5, 10000), dtype=np.float32)
gen.uniform(d_a)
a = d_a.copy_to_host()
print(a)
```

--------------------------------

### MTGP32 Engine Constructor with State and Parameters

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__mtgp32_8h_source.html

Constructs an MTGP32 engine instance using an existing state, parameters, and a block ID. Initializes internal tables based on the provided parameters.

```cpp
__forceinline__ __device__ __host__ mtgp32_engine(const mtgp32_state& m_state,
    const mtgp32_params* params,
    int bid)
{
    this->m_state = m_state;
    pos_tbl = params->pos_tbl[bid];
    sh1_tbl = params->sh1_tbl[bid];
    sh2_tbl = params->sh2_tbl[bid];
    mask = params->mask[0];
    for (int j = 0; j < MTGP_TS; j++) {
        param_tbl[j] = params->param_tbl[bid][j];
        temper_tbl[j] = params->temper_tbl[bid][j];
        single_temper_tbl[j] = params->single_temper_tbl[bid][j];
    }
}
```

--------------------------------

### Set ROCRAND_PATH Environment Variable

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

If rocRAND is built from source and not installed or installed in a non-standard directory, set the `ROCRAND_PATH` environment variable to the library's location.

```bash
export ROCRAND_PATH=~rocm-libraries/projects/rocrand/build/library/
```

--------------------------------

### Install rocRAND with Non-Standard ROCm Location

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

To install rocRAND when ROCm is not in the default location, use the `CMAKE_PREFIX_PATH` CMake option or set the `ROCM_PATH` environment variable.

```bash
cmake -DCMAKE_PREFIX_PATH=</path/to/opt/rocm/>
```

--------------------------------

### Initialize Philox4x32_10 Engine with Custom Seed

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__philox4x32__10_8h_source.html

Constructs a Philox4x32_10 engine with a specified seed, subsequence, and offset. This allows for reproducible random number generation sequences.

```cpp
__forceinline__ __device__ __host__ philox4x32_10_engine(const unsigned long long seed,
const unsigned long long subsequence,
const unsigned long long offset)
{
this->seed(seed, subsequence, offset);
}
```

--------------------------------

### sobol32_engine Constructor (Move)

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/classrocrand__cpp_1_1sobol32__engine.html

Move constructs a new engine from an existing one, transferring the state.

```APIDOC
## ◆ sobol32_engine() [3/3]
template<unsigned int DefaultNumDimensions = 1>
| rocrand_cpp::sobol32_engine< DefaultNumDimensions >::sobol32_engine | ( | sobol32_engine< DefaultNumDimensions > && | _rhs_ | )
inline noexcept
Move construct from an other engine, moving the state over.

Parameters
     rhs| the engine to move-from
* The moved-from engine is safe to assign to or destroy, but otherwise cannot be used.
* This engine will continue the sequence generated by `rhs`.
```

--------------------------------

### rocrand_get_version

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8h_source.html

Get the version of the ROCRand library.

```APIDOC
## rocrand_get_version

### Description
Get the version of the ROCRand library.

### Signature
```c
rocrand_status ROCRANDAPI rocrand_get_version(int *version)
```

### Parameters
* `version` (int *) - Pointer to store the version number.

### Return Value
* `rocrand_status` - Status code indicating success or failure.
```

--------------------------------

### rocrand_init (sobol64)

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/cpp-api.html

Initializes the sobol64 generator state.

```APIDOC
## rocrand_init (sobol64)

### Description
Initialize sobol64 state. Initializes the sobol64 generator `state` with the given direction `vectors` and `offset`.

### Parameters
* **vectors** – Direction vectors
* **offset** – Absolute offset into sequence
* **state** – Pointer to state to initialize
```

--------------------------------

### Initialize MTGP32 States

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/cpp-api.html

Initializes MTGP32 states on the host. Allocates state array in host memory, initializes it, and copies the result to device or host memory. Ensure parameters are correctly provided.

```cpp
__host__ inline rocrand_status rocrand_make_state_mtgp32(rocrand_state_mtgp32 *state, mtgp32_fast_params params[], int n, unsigned long long seed)
```

--------------------------------

### param()

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/classrocrand__cpp_1_1normal__distribution.html

Gets or sets the distribution parameter object.

```APIDOC
## param() const

### Description
Returns the distribution parameter object.

### Returns
- **param_type**: The distribution parameter object.

## param(const param_type &params)

### Description
Sets the distribution parameter object.

### Parameters
- **params** (const param_type &) - The distribution parameters to set.
```

--------------------------------

### rocrand_init

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__threefry2x32__20_8h_source.html

Initializes the threefry2x32_20 engine state with the provided seed, subsequence, and offset.

```APIDOC
## rocrand_init

### Description
Initializes the threefry2x32_20 engine state.

### Signature
__forceinline__ __device__ __host__ void rocrand_init(const unsigned long long seed, const unsigned long long subsequence, const unsigned long long offset, rocrand_state_threefry2x32_20* state)

### Parameters
* **seed** (const unsigned long long) - The seed for the random number generator.
* **subsequence** (const unsigned long long) - The subsequence number.
* **offset** (const unsigned long long) - The offset for the random number generator.
* **state** (rocrand_state_threefry2x32_20*) - Pointer to the state object to be initialized.
```

--------------------------------

### rocrand_get_direction_vectors64

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8h_source.html

Get the vector for 64-bit (scrambled-)sobol generation.

```APIDOC
## rocrand_get_direction_vectors64

### Description
Get the vector for 64-bit (scrambled-)sobol generation.

### Signature
```c
rocrand_status ROCRANDAPI rocrand_get_direction_vectors64(const unsigned long long **vectors, rocrand_direction_vector_set set)
```

### Parameters
* `vectors` (const unsigned long long **) - Pointer to store the array of direction vectors.
* `set` (rocrand_direction_vector_set) - The set of direction vectors to retrieve.

### Return Value
* `rocrand_status` - Status code indicating success or failure.
```

--------------------------------

### Initialize threefry2x32_20 Engine with existing generator

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8hpp_source.html

Initializes a threefry2x32_20 engine using an existing rocrand_generator. Throws an error if the provided generator is null.

```cpp
explicit threefry2x32_20_engine(rocrand_generator& generator) : m_generator(generator)
{
    if(generator == NULL)
    {
        throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
    }
    generator = NULL;
}
```

--------------------------------

### rocrand_get_direction_vectors32

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8h_source.html

Get the vector for 32-bit (scrambled-)sobol generation.

```APIDOC
## rocrand_get_direction_vectors32

### Description
Get the vector for 32-bit (scrambled-)sobol generation.

### Signature
```c
rocrand_status ROCRANDAPI rocrand_get_direction_vectors32(const unsigned int **vectors, rocrand_direction_vector_set set)
```

### Parameters
* `vectors` (const unsigned int **) - Pointer to store the array of direction vectors.
* `set` (rocrand_direction_vector_set) - The set of direction vectors to retrieve.

### Return Value
* `rocrand_status` - Status code indicating success or failure.
```

--------------------------------

### rocrand_get_scramble_constants64

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8h_source.html

Get the scramble constants for 64-bit scrambled sobol generation.

```APIDOC
## rocrand_get_scramble_constants64

### Description
Get the scramble constants for 64-bit scrambled sobol generation.

### Signature
rocrand_status ROCRANDAPI rocrand_get_scramble_constants64(const unsigned long long **constants)
```

--------------------------------

### rocrand_init (sobol32)

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/cpp-api.html

Initializes the SOBOL32 generator state.

```APIDOC
## rocrand_init (sobol32)

### Description
Initialize SOBOL32 state. Initializes the SOBOL32 generator `state` with the given direction `vectors` and `offset`.

### Parameters
* **vectors** – Direction vectors
* **offset** – Absolute offset into sequence
* **state** – Pointer to state to initialize
```

--------------------------------

### Initialize MTGP32 States

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__mtgp32_8h_source.html

Initializes MTGP32 states on the host. This function requires an array of fast parameters, the number of states, and a seed.

```cpp
__host__ rocrand_status rocrand_make_state_mtgp32(rocrand_state_mtgp32 *state, mtgp32_fast_params params[], int n, unsigned long long seed)
```

--------------------------------

### rocrand_get_scramble_constants32

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8h_source.html

Get the scramble constants for 32-bit scrambled sobol generation.

```APIDOC
## rocrand_get_scramble_constants32

### Description
Get the scramble constants for 32-bit scrambled sobol generation.

### Signature
```c
rocrand_status ROCRANDAPI rocrand_get_scramble_constants32(const unsigned int **constants)
```

### Parameters
* `constants` (const unsigned int **) - Pointer to store the array of scramble constants.

### Return Value
* `rocrand_status` - Status code indicating success or failure.
```

--------------------------------

### scrambled_sobol32_engine Member Functions

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/classrocrand__cpp_1_1scrambled__sobol32__engine.html

Functions to get and set engine properties and limits.

```APIDOC
## dimensions()

template<unsigned int DefaultNumDimensions = 1>
| void rocrand_cpp::scrambled_sobol32_engine< DefaultNumDimensions >::dimensions | ( | dimensions_num_type | _value_ | ) |
---|---|---|---|---|
inline
Set the number of dimensions of a quasi-random 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
     value| Number of dimensions
---
See also: rocrand_set_quasi_random_generator_dimensions()

## max()

template<unsigned int DefaultNumDimensions = 1>
| static constexpr result_type rocrand_cpp::scrambled_sobol32_engine< DefaultNumDimensions >::max | ( | | ) |
---|---|---|---|
inlinestaticconstexpr
Returns the largest possible value that can be generated by the engine.

## min()

template<unsigned int DefaultNumDimensions = 1>
| static constexpr result_type rocrand_cpp::scrambled_sobol32_engine< DefaultNumDimensions >::min | ( | | ) |
---|---|---|---|
inlinestaticconstexpr
Returns the smallest possible value that can be generated by the engine.

## offset()

template<unsigned int DefaultNumDimensions = 1>
| void rocrand_cpp::scrambled_sobol32_engine< DefaultNumDimensions >::offset | ( | offset_type | _value_ | ) |
---|---|---|---|---|
inline
Sets the offset of a random number engine.
Offset represents a number of the random number engine's states that should be skipped before first value is generated.
* This operation resets the engine's internal state.
* This operation does not change the engine's seed or the number of dimensions.

Parameters
     value| New absolute offset
---
See also: rocrand_set_offset()
```

--------------------------------

### Initialize Xorwow Engine with Existing Generator

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8hpp_source.html

Initializes a Xorwow engine using an existing ROCRAND generator. Throws an error if the provided generator is not created.

```cpp
explicit xorwow_engine(rocrand_generator& generator)
: m_generator(generator)
{
    if(generator == NULL)
    {
        throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
    }
    generator = NULL;
}
```

--------------------------------

### rocrand_cpp::random_device Usage

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/cpp-api.html

Example demonstrating the use of rocrand_cpp::random_device to seed a PRNG engine.

```APIDOC
## rocrand_cpp::random_device Usage

### Description
This example shows how `rocrand_cpp::random_device` can be used to seed a pseudo-random number engine like `rocrand_cpp::mtgp32_engine`.

### Code
```cpp
#include <rocrand/rocrand.hpp>

int main()
{
    const size_t size = 8192;
    float * output;
    hipMalloc(&output, size * sizeof(float));

    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);
}
```
```

--------------------------------

### rocrand_init

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__sobol32_8h_source.html

Initializes the SOBOL32 state with provided vectors and offset.

```APIDOC
## rocrand_init

### Description
Initializes SOBOL32 state.

### Signature
__forceinline__ __device__ __host__ void rocrand_init(const unsigned int* vectors, const unsigned int offset, rocrand_state_sobol32* state)

### Parameters
- **vectors** (const unsigned int*) - Pointer to the array of Sobol vectors.
- **offset** (const unsigned int) - The starting offset for the generator.
- **state** (rocrand_state_sobol32*) - Pointer to the state object to be initialized.
```

--------------------------------

### Sobol32 Engine Constructor (with offset)

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__sobol32_8h_source.html

Initializes the Sobol32 engine with a given set of vectors and an offset. The offset is used to discard initial states.

```cpp
__forceinline__ __device__ __host__ sobol32_engine(const unsigned int* vectors,
 const unsigned int offset)
 : m_state(0, 0, vectors)
{
 discard_state(offset);
}
```

--------------------------------

### Get rocrand_cpp version

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/group__rocrandhostcpp.html

Retrieves the version of the rocRAND library. This function returns the version number as an integer.

```cpp
int rocrand_cpp::version ()
```

--------------------------------

### sobol64_engine()

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/functions_s.html

Constructor for the sobol64_engine.

```APIDOC
## sobol64_engine()

### Description
Constructor for the `rocrand_cpp::sobol64_engine`.

### Method
Constructor

### Parameters
- `DefaultNumDimensions` (template parameter): The default number of dimensions for the engine.
```

--------------------------------

### Get rocRAND Library Version

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/python-api.html

Retrieves the version number of the rocRAND library using the `get_version()` function.

```python
rocrand.get_version()
```

--------------------------------

### Initialize Philox4x32_10 Engine with Default Seed

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__philox4x32__10_8h_source.html

Constructs a Philox4x32_10 engine using the default seed value. This is a convenient way to initialize the generator for basic use.

```cpp
__forceinline__ __device__ __host__ philox4x32_10_engine()
{
this->seed(ROCRAND_PHILOX4x32_DEFAULT_SEED, 0, 0);
}
```

--------------------------------

### rocrand_init (scrambled_sobol64)

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/cpp-api.html

Initializes the scrambled_sobol64 generator state.

```APIDOC
## rocrand_init (scrambled_sobol64)

### Description
Initialize scrambled_sobol64 state. Initializes the scrambled_sobol64 generator `state` with the given direction `vectors` and `offset`.

### Parameters
* **vectors** – Direction vectors
* **scramble_constant** – Constant used for scrambling the sequence
* **offset** – Absolute offset into sequence
* **state** – Pointer to state to initialize
```

--------------------------------

### Get rocRAND Version

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8hpp_source.html

Retrieves the version of the rocRAND library. It returns an integer representing the version and throws a rocrand_cpp::error if the status is not ROCRAND_STATUS_SUCCESS.

```cpp
inline int version()
{
 int x;
 rocrand_status status = rocrand_get_version(&x);
 if(status != ROCRAND_STATUS_SUCCESS)
 {
 throw rocrand_cpp::error(status);
 }
 return x;
 }
```

--------------------------------

### Get Next Random Number - ROCRAND MRG32k3a

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__mrg32k3a_8h_source.html

Generates the next pseudo-random unsigned integer. The returned value is in the range [1, ROCRAND_MRG32K3A_M1].

```cpp
__forceinline__ __device__ __host__ unsigned int operator()()
{
return this->next();
}
```

```cpp
__forceinline__ __device__ __host__
unsigned int next()
{
const unsigned int p1 = mod_m1(detail::mad_u64_u32(
ROCRAND_MRG32K3A_A12,
m_state.g1[1],
detail::mul_u64_u32(ROCRAND_MRG32K3A_A13N, (ROCRAND_MRG32K3A_M1 - m_state.g1[0]))));

m_state.g1[0] = m_state.g1[1];
m_state.g1[1] = m_state.g1[2];
m_state.g1[2] = p1;

const unsigned int p2 = mod_m2(detail::mad_u64_u32(
ROCRAND_MRG32K3A_A21,
m_state.g2[2],
detail::mul_u64_u32(ROCRAND_MRG32K3A_A23N, (ROCRAND_MRG32K3A_M2 - m_state.g2[0]))));

m_state.g2[0] = m_state.g2[1];
m_state.g2[1] = m_state.g2[2];
m_state.g2[2] = p2;

return (p1 - p2) + (p1 <= p2 ? ROCRAND_MRG32K3A_M1 : 0);
}
```

--------------------------------

### rocrand_init

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__threefry2x64__20_8h_source.html

Initializes the rocrand_state_threefry2x64_20 state with a seed, subsequence, and offset.

```APIDOC
## rocrand_init

### Description
Initializes the rocrand_state_threefry2x64_20 state.

### Signature
__forceinline__ __device__ __host__ void rocrand_init(const unsigned long long seed, const unsigned long long subsequence, const unsigned long long offset, rocrand_state_threefry2x64_20* state)

### Parameters
- **seed** (unsigned long long) - The seed for the random number generator.
- **subsequence** (unsigned long long) - The subsequence identifier.
- **offset** (unsigned long long) - The offset for the generator.
- **state** (rocrand_state_threefry2x64_20*) - Pointer to the state to be initialized.
```

--------------------------------

### mrg31k3p_engine Constructor (Default)

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__mrg31k3p_8h_source.html

Initializes the MRG31k3p engine with the default seed.

```APIDOC
## mrg31k3p_engine()

### Description
Initializes the MRG31k3p engine with the default seed value (ROCRAND_MRG31K3P_DEFAULT_SEED).

### Method
`mrg31k3p_engine()`

### Parameters
None
```

--------------------------------

### Build rocRAND for ROCm Platform

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

Use `hipcc` as the compiler and specify the CMake module path for `FindHIP.cmake`. The default installation directory for `FindHIP.cmake` is `/opt/rocm/hip/cmake`.

```bash
sudo make install
```

--------------------------------

### Run Configuration Tuning Script

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/conceptual/dynamic_ordering_configuration.html

Executes the `select_best_config.py` script to process benchmark results and generate dynamic ordering configurations. This command includes options for outputting SVG plots and specifying the output directory for generated C++ header files.

```bash
./rocm-libraries/projects/rocrand/scripts/config-tuning/select_best_config.py --plot-out ./rocrand-tuning.svg --out-dir ./rocm-libraries/projects/rocrand/library/src/rng/config/ ./rocm-libraries/projects/rocrand/build/benchmark/tuning/rocrand_tuning_gfx908.json ./rocm-libraries/projects/rocrand/build/benchmark/tuning/rocrand_tuning_gfx1030.json
```

--------------------------------

### rocrand_create_discrete_distribution

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/cpp-api.html

Constructs the histogram for a custom discrete distribution using provided probabilities. The distribution covers `size` 32-bit unsigned integers starting from `offset`.

```APIDOC
## rocrand_create_discrete_distribution

### Description
Construct the histogram for a custom discrete distribution.

### Parameters
* **probabilities** (const double *) - probabilities of the the distribution in host memory
* **size** (unsigned int) - size of `probabilities`
* **offset** (unsigned int) - offset of values
* **discrete_distribution** (rocrand_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 null
* ROCRAND_STATUS_OUT_OF_RANGE if `size` was zero
* ROCRAND_STATUS_SUCCESS if the histogram was constructed successfully
```

--------------------------------

### threefry2x32_20_engine Constructor (move)

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/classrocrand__cpp_1_1threefry2x32__20__engine.html

Move constructs a new engine from an existing one, transferring the internal state.

```APIDOC
## threefry2x32_20_engine() [3/3]

template<unsigned long long DefaultSeed = 0>
| rocrand_cpp::threefry2x32_20_engine< DefaultSeed >::threefry2x32_20_engine | ( | threefry2x32_20_engine< DefaultSeed > && | _rhs_ |
)
inline noexcept

Move construct from an other engine, moving the state over.

### Parameters
- **rhs**: the engine to move-from

* The moved-from engine is safe to assign to or destroy, but otherwise cannot be used.
* This engine will continue the sequence generated by `rhs`.
```

--------------------------------

### rocrand_get_direction_vectors32

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/group__rocrandhost.html

Gets the direction vectors for 32-bit scrambled Sobol generation. This function retrieves the pointer to the direction vectors used for generating 32-bit scrambled Sobol sequences.

```APIDOC
## rocrand_get_direction_vectors32

### Description
Get the vector for 32-bit (scrambled-)sobol generation.

### Parameters
- **vectors** (const unsigned int **) - location where to write the vector pointer to
- **set** (rocrand_direction_vector_set) - which direction vector set to use

### Returns
- ROCRAND_STATUS_OUT_OF_RANGE if `set` was invalid for this method
- ROCRAND_STATUS_SUCCESS if the pointer was set succesfully
```

--------------------------------

### Set Offset for Philox Engine

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8hpp_source.html

Sets the offset for the Philox4x32-10 engine. This is used to control the starting point of the random number sequence. Throws an exception if setting the offset fails.

```cpp
void offset(offset_type value)
{
    rocrand_status status = rocrand_set_offset(this->m_generator, value);
    if(status != ROCRAND_STATUS_SUCCESS) throw rocrand_cpp::error(status);
}
```

--------------------------------

### threefry2x64_20_engine Constructor

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8hpp_source.html

Initializes the threefry2x64_20_engine with a given rocrand_generator. Throws an error if the generator is not created.

```cpp
explicit threefry2x64_20_engine(rocrand_generator& generator) : m_generator(generator)
{
if(generator == NULL)
{
throw rocrand_cpp::error(ROCRAND_STATUS_NOT_CREATED);
}
generator = NULL;
}
```

--------------------------------

### Get Skein Key Stream Parity for unsigned long long

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__threefry__common_8h_source.html

Returns the Skein key stream parity for unsigned long long integers. This is a device and host callable function.

```cpp
__forceinline__ __device__ __host__ unsigned long long skein_ks_parity<unsigned long long>()
{
return SKEIN_KS_PARITY64;
}
```

--------------------------------

### Run rocRAND tuning benchmarks

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/conceptual/dynamic_ordering_configuration.html

Execute the built tuning benchmarks and save the results in JSON format. Ensure the GPU is thermally stable and not under concurrent load for accurate results. Use `--benchmark_filter` to run specific subsets of benchmarks.

```bash
cd ./build/benchmark/tuning
./benchmark_rocrand_tuning --benchmark_out_format=json --benchmark_out=rocrand_tuning_gfx908.json

```

--------------------------------

### MT19937 Engine Constructor

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8hpp_source.html

Constructs an MT19937 engine with a specified seed and ordering. It creates a new ROCRAND generator internally. If creation or subsequent setup fails, it cleans up and throws an exception.

```cpp
rocrand_status status;
status = rocrand_create_generator(&m_generator, this->type());
if(status != ROCRAND_STATUS_SUCCESS)
throw rocrand_cpp::error(status);
try
{
this->order(order_value);
this->seed(seed_value);
}
catch(...)
{
(void)rocrand_destroy_generator(m_generator);
throw;
}
```

--------------------------------

### rocrand_init (scrambled_sobol32)

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/api-reference/cpp-api.html

Initializes the scrambled_sobol32 generator state.

```APIDOC
## rocrand_init (scrambled_sobol32)

### Description
Initialize scrambled_sobol32 state. Initializes the scrambled_sobol32 generator `state` with the given direction `vectors` and `offset`.

### Parameters
* **vectors** – Direction vectors
* **scramble_constant** – Constant used for scrambling the sequence
* **offset** – Absolute offset into sequence
* **state** – Pointer to state to initialize
```

--------------------------------

### rocrand_init (sobol64)

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/group__rocranddevice.html

Initializes the sobol64 state for random number generation.

```APIDOC
## rocrand_init (sobol64)

### Description
Initialize sobol64 state.

### Signature
__forceinline__ __device__ __host__ void | rocrand_init (const unsigned long long int *vectors, const unsigned int offset, rocrand_state_sobol64 *state)
```

--------------------------------

### Link rocRAND Fortran Library with HIP

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/fortran-api-reference.html

Example compilation command for a Fortran program using the rocRAND Fortran interface. It specifies linking against the rocRAND Fortran and rocRAND libraries, and the HIP library.

```bash
# Compile on an AMD platform (link HIP library: ${HIP_ROOT_DIR}/lib).
# Note: ${HIP_ROOT_DIR} points to the directory where HIP was installed.
gfortran <input-file>.f90 hip_m.f90 rocrand_m.f90  -lrocrand_fortran -lrocrand -L${HIP_ROOT_DIR}/lib
```

--------------------------------

### rocrand_init

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__threefry4x32__20_8h_source.html

Initializes the rocrand_state_threefry4x32_20 state with a seed, subsequence, and offset.

```APIDOC
## rocrand_init

### Description
Initializes the rocrand_state_threefry4x32_20 state with a seed, subsequence, and offset.

### Signature
```cpp
__forceinline__ __device__ __host__ void rocrand_init(const unsigned long long seed, const unsigned long long subsequence, const unsigned long long offset, rocrand_state_threefry4x32_20* state)
```

### Parameters
* **seed** (unsigned long long) - The seed for the random number generator.
* **subsequence** (unsigned long long) - The subsequence number.
* **offset** (unsigned long long) - The offset for the generator.
* **state** (rocrand_state_threefry4x32_20*) - Pointer to the state to be initialized.
```

--------------------------------

### scrambled_sobol64_engine Constructor (Move)

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/classrocrand__cpp_1_1scrambled__sobol64__engine.html

Move constructs a scrambled_sobol64_engine from another engine, transferring its state.

```APIDOC
## scrambled_sobol64_engine() [3/3]
template<unsigned int DefaultNumDimensions = 1>
| rocrand_cpp::scrambled_sobol64_engine< DefaultNumDimensions >::scrambled_sobol64_engine | ( | scrambled_sobol64_engine< DefaultNumDimensions > && | _rhs_ | ) |
---|---|---|---|--- 
inlinesnoexcept
Move construct from an other engine, moving the state over.

Parameters
     rhs| the engine to move-from
---
* The moved-from engine is safe to assign to or destroy, but otherwise cannot be used.
* This engine will continue the sequence generated by `rhs`.
```

--------------------------------

### Engine Box-Muller Helper Functions

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand__common_8h_source.html

A helper struct to manage the state of random number engines using the Box-Muller transform. It provides functions to check for, get, and save generated float and double values.

```c++
static __forceinline__ __device__ __host__ bool has_float(const Engine* engine)
{
return engine->m_state.boxmuller_float != ROCRAND_NAN_FLOAT;
}
```

```c++
static __forceinline__ __device__ __host__ float get_float(Engine* engine)
{
const float ret = engine->m_state.boxmuller_float;
engine->m_state.boxmuller_float = ROCRAND_NAN_FLOAT;
return ret;
}
```

```c++
static __forceinline__ __device__ __host__ void save_float(Engine* engine, float f)
{
engine->m_state.boxmuller_float = f;
}
```

```c++
static __forceinline__ __device__ __host__ bool has_double(const Engine* engine)
{
return engine->m_state.boxmuller_double != ROCRAND_NAN_DOUBLE;
}
```

```c++
static __forceinline__ __device__ __host__
double get_double(Engine* engine)
{
const double ret = engine->m_state.boxmuller_double;
engine->m_state.boxmuller_double = ROCRAND_NAN_DOUBLE;
return ret;
}
```

```c++
static __forceinline__ __device__ __host__ void save_double(Engine* engine, double d)
{
engine->m_state.boxmuller_double = d;
}
```

--------------------------------

### Constructor for threefry4x64_20_engine

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8hpp_source.html

Constructs a threefry4x64_20_engine with a specified seed, offset, and ordering. It creates a RocRAND generator and configures it, throwing an exception on failure.

```cpp
threefry4x64_20_engine(seed_type seed_value = DefaultSeed,
offset_type offset_value = 0,
order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
{
rocrand_status status;
status = rocrand_create_generator(&m_generator, this->type());
if(status != ROCRAND_STATUS_SUCCESS)
throw rocrand_cpp::error(status);
try
{
if(offset_value > 0)
{
this->offset(offset_value);
}
this->order(order_value);
this->seed(seed_value);
}
catch(...)
{
(void)rocrand_destroy_generator(m_generator);
throw;
}
}
```

--------------------------------

### Class Members starting with 'd'

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/functions_d.html

This section lists class members whose names begin with the letter 'd'. It includes variables like 'default_num_dimensions' and 'default_seed', functions such as 'dimensions()', and typedefs like 'dimensions_num_type' and 'distribution_type'.

```APIDOC
## Class Members - d

### Variables
- **default_num_dimensions** : rocrand_cpp::scrambled_sobol32_engine< DefaultNumDimensions >, rocrand_cpp::scrambled_sobol64_engine< DefaultNumDimensions >, rocrand_cpp::sobol32_engine< DefaultNumDimensions >, rocrand_cpp::sobol64_engine< DefaultNumDimensions >
- **default_seed** : rocrand_cpp::lfsr113_engine< DefaultSeedX, DefaultSeedY, DefaultSeedZ, DefaultSeedW >, rocrand_cpp::mrg31k3p_engine< DefaultSeed >, rocrand_cpp::mrg32k3a_engine< DefaultSeed >, rocrand_cpp::mt19937_engine< DefaultSeed >, rocrand_cpp::mtgp32_engine< DefaultSeed >, rocrand_cpp::philox4x32_10_engine< DefaultSeed >, rocrand_cpp::threefry2x32_20_engine< DefaultSeed >, rocrand_cpp::threefry2x64_20_engine< DefaultSeed >, rocrand_cpp::threefry4x32_20_engine< DefaultSeed >, rocrand_cpp::threefry4x64_20_engine< DefaultSeed >, rocrand_cpp::xorwow_engine< DefaultSeed >

### Functions
- **dimensions()** : rocrand_cpp::scrambled_sobol32_engine< DefaultNumDimensions >, rocrand_cpp::scrambled_sobol64_engine< DefaultNumDimensions >, rocrand_cpp::sobol32_engine< DefaultNumDimensions >, rocrand_cpp::sobol64_engine< DefaultNumDimensions >

### Typedefs
- **dimensions_num_type** : rocrand_cpp::scrambled_sobol32_engine< DefaultNumDimensions >, rocrand_cpp::scrambled_sobol64_engine< DefaultNumDimensions >, rocrand_cpp::sobol32_engine< DefaultNumDimensions >, rocrand_cpp::sobol64_engine< DefaultNumDimensions >
- **distribution_type** : rocrand_cpp::lognormal_distribution< RealType >::param_type, rocrand_cpp::normal_distribution< RealType >::param_type, rocrand_cpp::poisson_distribution< IntType >::param_type
```

--------------------------------

### Build tuning benchmarks for rocRAND

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/conceptual/dynamic_ordering_configuration.html

Enable and build the `benchmark_rocrand_tuning` target using CMake. Specify the GPU architectures to build for using the `GPU_TARGETS` variable. Ensure the `BUILD_BENCHMARK` and `BUILD_BENCHMARK_TUNING` options are set to ON.

```bash
cd rocm-libraries/projects/rocrand
cmake -S . -B ./build
   -D BUILD_BENCHMARK=ON
   -D BUILD_BENCHMARK_TUNING=ON
   -D CMAKE_CXX_COMPILER=/opt/rocm/bin/amdclang++
   -D GPU_TARGETS=gfx908
cmake --build build --target benchmark_rocrand_tuning

```

--------------------------------

### Run Fortran Wrapper Unit Tests

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/fortran-api-reference.html

Execute the compiled unit tests for the rocRAND Fortran interface.

```bash
./test/test_rocrand_fortran_wrapper
```

--------------------------------

### Build Fortran Wrapper Unit Tests

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/fortran-api-reference.html

Compile the unit tests specifically for the rocRAND Fortran interface using the cmake --build command.

```bash
cmake --build . --target test_rocrand_fortran_wrapper
```

--------------------------------

### Create threefry2x64_20 Engine

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8hpp_source.html

Constructs a threefry2x64_20 engine with optional seed, offset, and ordering. Throws an error if generator creation fails.

```cpp
threefry2x64_20_engine(seed_type seed_value = DefaultSeed,
offset_type offset_value = 0,
order_type order_value = ROCRAND_ORDERING_PSEUDO_DEFAULT)
{
    rocrand_status status;
    status = rocrand_create_generator(&m_generator, this->type());
    if(status != ROCRAND_STATUS_SUCCESS)
        throw rocrand_cpp::error(status);
    try
    {
        if(offset_value > 0)
        {
            this->offset(offset_value);
        }
        this->order(order_value);
        this->seed(seed_value);
    }
    catch(...)
    {
        (void)rocrand_destroy_generator(m_generator);
        throw;
    }
}
```

--------------------------------

### philox4x32_10_engine Constructors and Destructor

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/classrocrand__cpp_1_1philox4x32__10__engine-members.html

Details on how to construct, copy, move, and destroy instances of the philox4x32_10_engine.

```APIDOC
## Constructor

### `philox4x32_10_engine(seed_type seed_value=DefaultSeed, offset_type offset_value=0, order_type order_value=ROCRAND_ORDERING_PSEUDO_DEFAULT)`

Initializes the engine with a seed, offset, and ordering.

### `philox4x32_10_engine(rocrand_generator &generator)`

Initializes the engine using an existing rocrand_generator.

### `~philox4x32_10_engine() noexcept(false)`

Destructor for the engine.
```

--------------------------------

### Build rocRAND with CMake and make

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html

After configuring with CMake, use 'make' to build rocRAND. The '-j4' flag enables parallel building.

```bash
make -j4

```

--------------------------------

### Set Ordering for Scrambled Sobol 64-bit Engine

Source: https://rocm.docs.amd.com/projects/rocRAND/en/latest/doxygen/html/rocrand_8hpp_source.html

Sets the ordering for the scrambled_sobol64_engine. Throws an error if setting the ordering fails.

```cpp
void order(order_type value)
{
 rocrand_status status = rocrand_set_ordering(this->m_generator, value);
 if(status != ROCRAND_STATUS_SUCCESS)
 throw rocrand_cpp::error(status);
 }
```
Tokens:
Raw