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.

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

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

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

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

mt_state	_initial_state
	Base RNG state (seeded)

mt_state	_current_state
	Cached working RNG state.

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

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

◆ advance() [2/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.

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

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

◆ 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.

    {
      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;
    }