#include <algorithm>
#include <cinttypes>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <limits>
#include <iostream>
#include <iterator>
#include <type_traits>
#include <utility>
#include <locale>
#include <new>
#include <stdexcept>
#include "pcg_extras.hpp"

Include dependency graph for pcg_random.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	pcg_detail::default_multiplier< T >

struct	pcg_detail::default_increment< T >

class	pcg_detail::no_stream< itype >

class	pcg_detail::oneseq_stream< itype >

class	pcg_detail::specific_stream< itype >

class	pcg_detail::engine< xtype, itype, output_mixin, output_previous, stream_mixin, multiplier_mixin >

struct	pcg_detail::engine< xtype, itype, output_mixin, output_previous, stream_mixin, multiplier_mixin >::can_specify_stream_tag

struct	pcg_detail::engine< xtype, itype, output_mixin, output_previous, stream_mixin, multiplier_mixin >::no_specifiable_stream_tag

struct	pcg_detail::xsh_rs_mixin< xtype, itype >

struct	pcg_detail::xsh_rr_mixin< xtype, itype >

struct	pcg_detail::rxs_mixin< xtype, itype >

struct	pcg_detail::mcg_multiplier< T >

struct	pcg_detail::mcg_unmultiplier< T >

struct	pcg_detail::rxs_m_xs_mixin

struct	pcg_detail::rxs_m_mixin< xtype, itype >

struct	pcg_detail::xsl_rr_mixin< xtype, itype >

struct	pcg_detail::halfsize_trait< T >

struct	pcg_detail::halfsize_trait< pcg128_t >

struct	pcg_detail::halfsize_trait< uint64_t >

struct	pcg_detail::halfsize_trait< uint32_t >

struct	pcg_detail::halfsize_trait< uint16_t >

struct	pcg_detail::xsl_rr_rr_mixin< xtype, itype >

struct	pcg_detail::xsh_mixin< xtype, itype >

struct	pcg_detail::xsl_mixin< xtype, itype >

struct	pcg_detail::inside_out< baseclass >

class	pcg_detail::extended< table_pow2, advance_pow2, baseclass, extvalclass, kdd >

Namespaces
	pcg_detail

	pcg_engines

Macros
#define	PCG_ALWAYS_INLINE inline

#define	PCG_DEFINE_CONSTANT(type, what, kind, constant)

Typedefs
template<typename xtype , typename itype , template< typename XT, typename IT > class output_mixin, bool output_previous = (sizeof(itype) <= 8)>
using	pcg_detail::oneseq_base = engine< xtype, itype, output_mixin< xtype, itype >, output_previous, oneseq_stream< itype > >

template<typename xtype , typename itype , template< typename XT, typename IT > class output_mixin, bool output_previous = (sizeof(itype) <= 8)>
using	pcg_detail::unique_base = engine< xtype, itype, output_mixin< xtype, itype >, output_previous, unique_stream< itype > >

template<typename xtype , typename itype , template< typename XT, typename IT > class output_mixin, bool output_previous = (sizeof(itype) <= 8)>
using	pcg_detail::setseq_base = engine< xtype, itype, output_mixin< xtype, itype >, output_previous, specific_stream< itype > >

template<typename xtype , typename itype , template< typename XT, typename IT > class output_mixin, bool output_previous = (sizeof(itype) <= 8)>
using	pcg_detail::mcg_base = engine< xtype, itype, output_mixin< xtype, itype >, output_previous, no_stream< itype > >

typedef oneseq_base< uint8_t, uint16_t, xsh_rs_mixin >	pcg_engines::oneseq_xsh_rs_16_8

typedef oneseq_base< uint16_t, uint32_t, xsh_rs_mixin >	pcg_engines::oneseq_xsh_rs_32_16

typedef oneseq_base< uint32_t, uint64_t, xsh_rs_mixin >	pcg_engines::oneseq_xsh_rs_64_32

typedef oneseq_base< uint64_t, pcg128_t, xsh_rs_mixin >	pcg_engines::oneseq_xsh_rs_128_64

typedef unique_base< uint8_t, uint16_t, xsh_rs_mixin >	pcg_engines::unique_xsh_rs_16_8

typedef unique_base< uint16_t, uint32_t, xsh_rs_mixin >	pcg_engines::unique_xsh_rs_32_16

typedef unique_base< uint32_t, uint64_t, xsh_rs_mixin >	pcg_engines::unique_xsh_rs_64_32

typedef unique_base< uint64_t, pcg128_t, xsh_rs_mixin >	pcg_engines::unique_xsh_rs_128_64

typedef setseq_base< uint8_t, uint16_t, xsh_rs_mixin >	pcg_engines::setseq_xsh_rs_16_8

typedef setseq_base< uint16_t, uint32_t, xsh_rs_mixin >	pcg_engines::setseq_xsh_rs_32_16

typedef setseq_base< uint32_t, uint64_t, xsh_rs_mixin >	pcg_engines::setseq_xsh_rs_64_32

typedef setseq_base< uint64_t, pcg128_t, xsh_rs_mixin >	pcg_engines::setseq_xsh_rs_128_64

typedef mcg_base< uint8_t, uint16_t, xsh_rs_mixin >	pcg_engines::mcg_xsh_rs_16_8

typedef mcg_base< uint16_t, uint32_t, xsh_rs_mixin >	pcg_engines::mcg_xsh_rs_32_16

typedef mcg_base< uint32_t, uint64_t, xsh_rs_mixin >	pcg_engines::mcg_xsh_rs_64_32

typedef mcg_base< uint64_t, pcg128_t, xsh_rs_mixin >	pcg_engines::mcg_xsh_rs_128_64

typedef oneseq_base< uint8_t, uint16_t, xsh_rr_mixin >	pcg_engines::oneseq_xsh_rr_16_8

typedef oneseq_base< uint16_t, uint32_t, xsh_rr_mixin >	pcg_engines::oneseq_xsh_rr_32_16

typedef oneseq_base< uint32_t, uint64_t, xsh_rr_mixin >	pcg_engines::oneseq_xsh_rr_64_32

typedef oneseq_base< uint64_t, pcg128_t, xsh_rr_mixin >	pcg_engines::oneseq_xsh_rr_128_64

typedef unique_base< uint8_t, uint16_t, xsh_rr_mixin >	pcg_engines::unique_xsh_rr_16_8

typedef unique_base< uint16_t, uint32_t, xsh_rr_mixin >	pcg_engines::unique_xsh_rr_32_16

typedef unique_base< uint32_t, uint64_t, xsh_rr_mixin >	pcg_engines::unique_xsh_rr_64_32

typedef unique_base< uint64_t, pcg128_t, xsh_rr_mixin >	pcg_engines::unique_xsh_rr_128_64

typedef setseq_base< uint8_t, uint16_t, xsh_rr_mixin >	pcg_engines::setseq_xsh_rr_16_8

typedef setseq_base< uint16_t, uint32_t, xsh_rr_mixin >	pcg_engines::setseq_xsh_rr_32_16

typedef setseq_base< uint32_t, uint64_t, xsh_rr_mixin >	pcg_engines::setseq_xsh_rr_64_32

typedef setseq_base< uint64_t, pcg128_t, xsh_rr_mixin >	pcg_engines::setseq_xsh_rr_128_64

typedef mcg_base< uint8_t, uint16_t, xsh_rr_mixin >	pcg_engines::mcg_xsh_rr_16_8

typedef mcg_base< uint16_t, uint32_t, xsh_rr_mixin >	pcg_engines::mcg_xsh_rr_32_16

typedef mcg_base< uint32_t, uint64_t, xsh_rr_mixin >	pcg_engines::mcg_xsh_rr_64_32

typedef mcg_base< uint64_t, pcg128_t, xsh_rr_mixin >	pcg_engines::mcg_xsh_rr_128_64

typedef oneseq_base< uint8_t, uint8_t, rxs_m_xs_mixin >	pcg_engines::oneseq_rxs_m_xs_8_8

typedef oneseq_base< uint16_t, uint16_t, rxs_m_xs_mixin >	pcg_engines::oneseq_rxs_m_xs_16_16

typedef oneseq_base< uint32_t, uint32_t, rxs_m_xs_mixin >	pcg_engines::oneseq_rxs_m_xs_32_32

typedef oneseq_base< uint64_t, uint64_t, rxs_m_xs_mixin >	pcg_engines::oneseq_rxs_m_xs_64_64

typedef oneseq_base< pcg128_t, pcg128_t, rxs_m_xs_mixin >	pcg_engines::oneseq_rxs_m_xs_128_128

typedef unique_base< uint8_t, uint8_t, rxs_m_xs_mixin >	pcg_engines::unique_rxs_m_xs_8_8

typedef unique_base< uint16_t, uint16_t, rxs_m_xs_mixin >	pcg_engines::unique_rxs_m_xs_16_16

typedef unique_base< uint32_t, uint32_t, rxs_m_xs_mixin >	pcg_engines::unique_rxs_m_xs_32_32

typedef unique_base< uint64_t, uint64_t, rxs_m_xs_mixin >	pcg_engines::unique_rxs_m_xs_64_64

typedef unique_base< pcg128_t, pcg128_t, rxs_m_xs_mixin >	pcg_engines::unique_rxs_m_xs_128_128

typedef setseq_base< uint8_t, uint8_t, rxs_m_xs_mixin >	pcg_engines::setseq_rxs_m_xs_8_8

typedef setseq_base< uint16_t, uint16_t, rxs_m_xs_mixin >	pcg_engines::setseq_rxs_m_xs_16_16

typedef setseq_base< uint32_t, uint32_t, rxs_m_xs_mixin >	pcg_engines::setseq_rxs_m_xs_32_32

typedef setseq_base< uint64_t, uint64_t, rxs_m_xs_mixin >	pcg_engines::setseq_rxs_m_xs_64_64

typedef setseq_base< pcg128_t, pcg128_t, rxs_m_xs_mixin >	pcg_engines::setseq_rxs_m_xs_128_128

typedef oneseq_base< uint32_t, uint64_t, xsl_rr_mixin >	pcg_engines::oneseq_xsl_rr_64_32

typedef oneseq_base< uint64_t, pcg128_t, xsl_rr_mixin >	pcg_engines::oneseq_xsl_rr_128_64

typedef unique_base< uint32_t, uint64_t, xsl_rr_mixin >	pcg_engines::unique_xsl_rr_64_32

typedef unique_base< uint64_t, pcg128_t, xsl_rr_mixin >	pcg_engines::unique_xsl_rr_128_64

typedef setseq_base< uint32_t, uint64_t, xsl_rr_mixin >	pcg_engines::setseq_xsl_rr_64_32

typedef setseq_base< uint64_t, pcg128_t, xsl_rr_mixin >	pcg_engines::setseq_xsl_rr_128_64

typedef mcg_base< uint32_t, uint64_t, xsl_rr_mixin >	pcg_engines::mcg_xsl_rr_64_32

typedef mcg_base< uint64_t, pcg128_t, xsl_rr_mixin >	pcg_engines::mcg_xsl_rr_128_64

typedef oneseq_base< uint64_t, uint64_t, xsl_rr_rr_mixin >	pcg_engines::oneseq_xsl_rr_rr_64_64

typedef oneseq_base< pcg128_t, pcg128_t, xsl_rr_rr_mixin >	pcg_engines::oneseq_xsl_rr_rr_128_128

typedef unique_base< uint64_t, uint64_t, xsl_rr_rr_mixin >	pcg_engines::unique_xsl_rr_rr_64_64

typedef unique_base< pcg128_t, pcg128_t, xsl_rr_rr_mixin >	pcg_engines::unique_xsl_rr_rr_128_128

typedef setseq_base< uint64_t, uint64_t, xsl_rr_rr_mixin >	pcg_engines::setseq_xsl_rr_rr_64_64

typedef setseq_base< pcg128_t, pcg128_t, xsl_rr_rr_mixin >	pcg_engines::setseq_xsl_rr_rr_128_128

template<bitcount_t table_pow2, bitcount_t advance_pow2, typename BaseRNG , bool kdd = true>
using	pcg_engines::ext_std8 = extended< table_pow2, advance_pow2, BaseRNG, oneseq_rxs_m_xs_8_8, kdd >

template<bitcount_t table_pow2, bitcount_t advance_pow2, typename BaseRNG , bool kdd = true>
using	pcg_engines::ext_std16 = extended< table_pow2, advance_pow2, BaseRNG, oneseq_rxs_m_xs_16_16, kdd >

template<bitcount_t table_pow2, bitcount_t advance_pow2, typename BaseRNG , bool kdd = true>
using	pcg_engines::ext_std32 = extended< table_pow2, advance_pow2, BaseRNG, oneseq_rxs_m_xs_32_32, kdd >

template<bitcount_t table_pow2, bitcount_t advance_pow2, typename BaseRNG , bool kdd = true>
using	pcg_engines::ext_std64 = extended< table_pow2, advance_pow2, BaseRNG, oneseq_rxs_m_xs_64_64, kdd >

template<bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
using	pcg_engines::ext_oneseq_rxs_m_xs_32_32 = ext_std32< table_pow2, advance_pow2, oneseq_rxs_m_xs_32_32, kdd >

template<bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
using	pcg_engines::ext_mcg_xsh_rs_64_32 = ext_std32< table_pow2, advance_pow2, mcg_xsh_rs_64_32, kdd >

template<bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
using	pcg_engines::ext_oneseq_xsh_rs_64_32 = ext_std32< table_pow2, advance_pow2, oneseq_xsh_rs_64_32, kdd >

template<bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
using	pcg_engines::ext_setseq_xsh_rr_64_32 = ext_std32< table_pow2, advance_pow2, setseq_xsh_rr_64_32, kdd >

template<bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
using	pcg_engines::ext_mcg_xsl_rr_128_64 = ext_std64< table_pow2, advance_pow2, mcg_xsl_rr_128_64, kdd >

template<bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
using	pcg_engines::ext_oneseq_xsl_rr_128_64 = ext_std64< table_pow2, advance_pow2, oneseq_xsl_rr_128_64, kdd >

template<bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
using	pcg_engines::ext_setseq_xsl_rr_128_64 = ext_std64< table_pow2, advance_pow2, setseq_xsl_rr_128_64, kdd >

typedef pcg_engines::setseq_xsh_rr_64_32	pcg32

typedef pcg_engines::oneseq_xsh_rr_64_32	pcg32_oneseq

typedef pcg_engines::unique_xsh_rr_64_32	pcg32_unique

typedef pcg_engines::mcg_xsh_rs_64_32	pcg32_fast

typedef pcg_engines::setseq_xsl_rr_128_64	pcg64

typedef pcg_engines::oneseq_xsl_rr_128_64	pcg64_oneseq

typedef pcg_engines::unique_xsl_rr_128_64	pcg64_unique

typedef pcg_engines::mcg_xsl_rr_128_64	pcg64_fast

typedef pcg_engines::setseq_rxs_m_xs_8_8	pcg8_once_insecure

typedef pcg_engines::setseq_rxs_m_xs_16_16	pcg16_once_insecure

typedef pcg_engines::setseq_rxs_m_xs_32_32	pcg32_once_insecure

typedef pcg_engines::setseq_rxs_m_xs_64_64	pcg64_once_insecure

typedef pcg_engines::setseq_xsl_rr_rr_128_128	pcg128_once_insecure

typedef pcg_engines::oneseq_rxs_m_xs_8_8	pcg8_oneseq_once_insecure

typedef pcg_engines::oneseq_rxs_m_xs_16_16	pcg16_oneseq_once_insecure

typedef pcg_engines::oneseq_rxs_m_xs_32_32	pcg32_oneseq_once_insecure

typedef pcg_engines::oneseq_rxs_m_xs_64_64	pcg64_oneseq_once_insecure

typedef pcg_engines::oneseq_xsl_rr_rr_128_128	pcg128_oneseq_once_insecure

typedef pcg_engines::ext_setseq_xsh_rr_64_32< 1, 16, true >	pcg32_k2

typedef pcg_engines::ext_oneseq_xsh_rs_64_32< 1, 32, true >	pcg32_k2_fast

typedef pcg_engines::ext_setseq_xsh_rr_64_32< 6, 16, true >	pcg32_k64

typedef pcg_engines::ext_mcg_xsh_rs_64_32< 6, 32, true >	pcg32_k64_oneseq

typedef pcg_engines::ext_oneseq_xsh_rs_64_32< 6, 32, true >	pcg32_k64_fast

typedef pcg_engines::ext_setseq_xsh_rr_64_32< 6, 16, false >	pcg32_c64

typedef pcg_engines::ext_oneseq_xsh_rs_64_32< 6, 32, false >	pcg32_c64_oneseq

typedef pcg_engines::ext_mcg_xsh_rs_64_32< 6, 32, false >	pcg32_c64_fast

typedef pcg_engines::ext_setseq_xsl_rr_128_64< 5, 16, true >	pcg64_k32

typedef pcg_engines::ext_oneseq_xsl_rr_128_64< 5, 128, true >	pcg64_k32_oneseq

typedef pcg_engines::ext_mcg_xsl_rr_128_64< 5, 128, true >	pcg64_k32_fast

typedef pcg_engines::ext_setseq_xsl_rr_128_64< 5, 16, false >	pcg64_c32

typedef pcg_engines::ext_oneseq_xsl_rr_128_64< 5, 128, false >	pcg64_c32_oneseq

typedef pcg_engines::ext_mcg_xsl_rr_128_64< 5, 128, false >	pcg64_c32_fast

typedef pcg_engines::ext_setseq_xsh_rr_64_32< 10, 16, true >	pcg32_k1024

typedef pcg_engines::ext_oneseq_xsh_rs_64_32< 10, 32, true >	pcg32_k1024_fast

typedef pcg_engines::ext_setseq_xsh_rr_64_32< 10, 16, false >	pcg32_c1024

typedef pcg_engines::ext_oneseq_xsh_rs_64_32< 10, 32, false >	pcg32_c1024_fast

typedef pcg_engines::ext_setseq_xsl_rr_128_64< 10, 16, true >	pcg64_k1024

typedef pcg_engines::ext_oneseq_xsl_rr_128_64< 10, 128, true >	pcg64_k1024_fast

typedef pcg_engines::ext_setseq_xsl_rr_128_64< 10, 16, false >	pcg64_c1024

typedef pcg_engines::ext_oneseq_xsl_rr_128_64< 10, 128, false >	pcg64_c1024_fast

typedef pcg_engines::ext_setseq_xsh_rr_64_32< 14, 16, true >	pcg32_k16384

typedef pcg_engines::ext_oneseq_xsh_rs_64_32< 14, 32, true >	pcg32_k16384_fast

Functions
	pcg_detail::PCG_DEFINE_CONSTANT (pcg128_t, default, multiplier, PCG_128BIT_CONSTANT(2549297995355413924ULL, 4865540595714422341ULL)) PCG_DEFINE_CONSTANT(pcg128_t

	pcg_detail::PCG_128BIT_CONSTANT (6364136223846793005ULL, 1442695040888963407ULL)) template< typename itype > class unique_stream

template<typename CharT , typename Traits , typename xtype , typename itype , typename output_mixin , bool output_previous, typename stream_mixin , typename multiplier_mixin >
std::basic_ostream< CharT, Traits > &	pcg_detail::operator<< (std::basic_ostream< CharT, Traits > &out, const engine< xtype, itype, output_mixin, output_previous, stream_mixin, multiplier_mixin > &rng)

template<typename CharT , typename Traits , typename xtype , typename itype , typename output_mixin , bool output_previous, typename stream_mixin , typename multiplier_mixin >
std::basic_istream< CharT, Traits > &	pcg_detail::operator>> (std::basic_istream< CharT, Traits > &in, engine< xtype, itype, output_mixin, output_previous, stream_mixin, multiplier_mixin > &rng)

template<typename xtype , typename itype , typename output_mixin , bool output_previous, typename stream_mixin_lhs , typename multiplier_mixin_lhs , typename stream_mixin_rhs , typename multiplier_mixin_rhs >
itype	pcg_detail::operator- (const engine< xtype, itype, output_mixin, output_previous, stream_mixin_lhs, multiplier_mixin_lhs > &lhs, const engine< xtype, itype, output_mixin, output_previous, stream_mixin_rhs, multiplier_mixin_rhs > &rhs)

template<typename xtype , typename itype , typename output_mixin , bool output_previous, typename stream_mixin_lhs , typename multiplier_mixin_lhs , typename stream_mixin_rhs , typename multiplier_mixin_rhs >
bool	pcg_detail::operator== (const engine< xtype, itype, output_mixin, output_previous, stream_mixin_lhs, multiplier_mixin_lhs > &lhs, const engine< xtype, itype, output_mixin, output_previous, stream_mixin_rhs, multiplier_mixin_rhs > &rhs)

template<typename xtype , typename itype , typename output_mixin , bool output_previous, typename stream_mixin_lhs , typename multiplier_mixin_lhs , typename stream_mixin_rhs , typename multiplier_mixin_rhs >
bool	pcg_detail::operator!= (const engine< xtype, itype, output_mixin, output_previous, stream_mixin_lhs, multiplier_mixin_lhs > &lhs, const engine< xtype, itype, output_mixin, output_previous, stream_mixin_rhs, multiplier_mixin_rhs > &rhs)

	pcg_detail::PCG_DEFINE_CONSTANT (pcg128_t, mcg, multiplier, PCG_128BIT_CONSTANT(17766728186571221404ULL, 12605985483714917081ULL)) PCG_DEFINE_CONSTANT(pcg128_t

	pcg_detail::PCG_128BIT_CONSTANT (14422606686972528997ULL, 15009553638781119849ULL)) template< typename xtype

template<bitcount_t table_pow2, bitcount_t advance_pow2, typename baseclass , typename extvalclass , bool kdd>
bool	pcg_detail::operator== (const extended< table_pow2, advance_pow2, baseclass, extvalclass, kdd > &lhs, const extended< table_pow2, advance_pow2, baseclass, extvalclass, kdd > &rhs)

template<bitcount_t table_pow2, bitcount_t advance_pow2, typename baseclass , typename extvalclass , bool kdd>
bool	pcg_detail::operator!= (const extended< table_pow2, advance_pow2, baseclass, extvalclass, kdd > &lhs, const extended< table_pow2, advance_pow2, baseclass, extvalclass, kdd > &rhs)

template<typename CharT , typename Traits , bitcount_t table_pow2, bitcount_t advance_pow2, typename baseclass , typename extvalclass , bool kdd>
std::basic_ostream< CharT, Traits > &	pcg_detail::operator<< (std::basic_ostream< CharT, Traits > &out, const extended< table_pow2, advance_pow2, baseclass, extvalclass, kdd > &rng)

template<typename CharT , typename Traits , bitcount_t table_pow2, bitcount_t advance_pow2, typename baseclass , typename extvalclass , bool kdd>
std::basic_istream< CharT, Traits > &	pcg_detail::operator>> (std::basic_istream< CharT, Traits > &in, extended< table_pow2, advance_pow2, baseclass, extvalclass, kdd > &rng)

Variables
	pcg_detail::default

	pcg_detail::increment

	pcg_detail::mcg

	pcg_detail::unmultiplier

Macro Definition Documentation

◆ PCG_ALWAYS_INLINE

#define PCG_ALWAYS_INLINE inline

◆ PCG_DEFINE_CONSTANT

#define PCG_DEFINE_CONSTANT	(	type,
		what,
		kind,
		constant
	)

Value:

        template <>                                     \
        struct what ## _ ## kind<type> {                \
            static constexpr type kind() {              \
                return constant;                        \
            }                                           \
        };