Template class wrapping a single random number generator function. More...

#include <MooseRandomStateless.h>

Public Member Functions
	Generator (std::function< T(mt_state *)> rng_func, unsigned int seed)
	Construct a new Generator with a function and seed. More...

T	evaluate (std::size_t n) const
	Evaluate the n-th random number in the sequence. More...

void	advance (std::size_t count)
	Advance the internal RNG state by a fixed count. More...

Private Member Functions
void	advance (mt_state &state, std::size_t count)
	Advance a given RNG state `count` times. More...

Private Attributes
const std::function< T(mt_state *)>	_rng_func
	RNG function pointer. More...

mt_state	_initial_state
	Base RNG state (seeded) More...

mt_state	_current_state
	Cached working RNG state. More...

std::size_t	_current_index
	Index of next number to be generated. More...

Detailed Description

template<typename T>
class MooseRandomStateless::Generator< T >

Template class wrapping a single random number generator function.

Template Parameters

T	Output type of the RNG (e.g., `Real` or `unsigned int`)

Each Generator stores:

The RNG function pointer (from randistrs)
An initial state (seeded once)
A cached current state and index for fast sequential sampling

Definition at line 182 of file MooseRandomStateless.h.

Constructor & Destructor Documentation

◆ Generator()

template<typename T>

MooseRandomStateless::Generator< T >::Generator	(	std::function< T(mt_state *)>	rng_func,
		unsigned int	seed
	)

inline

Construct a new Generator with a function and seed.

Parameters

rng_func	RNG function to apply to `mt_state` (e.g., `mts_ldrand`)
seed	Seed used to initialize the base state

Definition at line 191 of file MooseRandomStateless.h.

       : _rng_func(std::move(rng_func))
     {
       // Create a new state with the given seed
       mts_seed32new(&_initial_state, seed);
       _current_state = _initial_state;
       _current_index = 0;
     }

Member Function Documentation

◆ advance() [1/2]

template<typename T>

void MooseRandomStateless::Generator< T >::advance ( std::size_t count )

inline

Advance the internal RNG state by a fixed count.

This resets _current_state to _initial_state after advancing.

Parameters

count Number of RNG calls to skip

Definition at line 231 of file MooseRandomStateless.h.

Referenced by MooseRandomStateless::advance(), and MooseRandomStateless::Generator< Real >::advance().

     {
       advance(_initial_state, count);
       _current_state = _initial_state;
       _current_index = 0;
     }

◆ advance() [2/2]

template<typename T>

void MooseRandomStateless::Generator< T >::advance	(	mt_state &	state,
		std::size_t	count
	)

inlineprivate

Advance a given RNG state count times.

Definition at line 240 of file MooseRandomStateless.h.

     {
       for (std::size_t i = 0; i < count; ++i)
         _rng_func(&state);
     }

◆ evaluate()

template<typename T>

T MooseRandomStateless::Generator< T >::evaluate ( std::size_t n ) const

inline

Evaluate the n-th random number in the sequence.

Uses cached state when n >= _current_index for sequential access. If n < _current_index, it resets to the initial seed and recomputes.

Parameters

n	0-based index in the random sequence

Returns: T The n-th random value

Definition at line 209 of file MooseRandomStateless.h.

Referenced by MooseRandomStateless::rand(), and MooseRandomStateless::randl().

     {
       if (n < _current_index)
       {
         _current_state = _initial_state;
         _current_index = 0;
       }
 
       T val = T();
       for (; _current_index <= n; ++_current_index)
         val = _rng_func(&_current_state);
 
       return val;
     }