#include <cstdint>
#include <array>
#include <limits>
#include <concepts>
#include <random>
#include <algorithm>
#include <bit>
#include <cassert>
#include <type_traits>
#include <ranges>
#include <string>
#include <string_view>
#include <unordered_set>
#include <vector>
#include <stdexcept>
#include <chrono>
#include <ios>
#include <istream>
#include <ostream>
#include <cstring>

RandX.hpp 的引用(Include)关系图:

类
class	RandX::SplitMix64
	SplitMix64 伪随机数生成器，64 位输出，周期 2^64。更多...
class	RandX::Xoshiro256StarStar
	Xoshiro256** 伪随机数生成器，64 位输出，周期 2^256-1。更多...
class	RandX::Xoroshiro128StarStar
	Xoroshiro128** 伪随机数生成器，64 位输出，周期 2^128-1。更多...
class	RandX::Xoshiro128StarStar
	Xoshiro128** 伪随机数生成器，32 位输出，周期 2^128-1。更多...
class	RandX::Xoroshiro64StarStar
	Xoroshiro64** 伪随机数生成器，32 位输出，周期 2^64-1。更多...
class	RandX::SFC64
	SFC64（Small Fast Counter）伪随机数生成器，64 位输出，周期 >= 2^64。更多...
class	RandX::RomuDuoJr
	RomuDuoJr 伪随机数生成器，64 位输出，周期估计 >= 2^51。更多...
class	RandX::ChaCha20
	ChaCha20 密码学安全伪随机数生成器（CSPRNG），64 位输出，符合 RFC 8439。更多...

命名空间
namespace	RandX
namespace	RandX::detail
namespace	RandX::ranges

概念
concept	RandX::detail::Character
concept	RandX::detail::IndexableState
concept	RandX::detail::SerializableEngine
concept	RandX::detail::JumpableEngine
	可跳跃引擎概念：支持 jump() 前进 2^N 步
concept	RandX::detail::StreamEngine
	流式引擎概念：可通过 MakeStreamEngine 创建互不重叠的子序列流
concept	RandX::detail::RandFillable

函数
template<std::same_as< std::uint32_t > Uint32>
constexpr float	RandX::FloatFromBits (Uint32 i) noexcept
template<std::same_as< std::uint64_t > Uint64>
constexpr double	RandX::DoubleFromBits (Uint64 i) noexcept
static constexpr std::uint64_t	RandX::detail::RotL (const std::uint64_t x, const int s) noexcept
static constexpr std::uint32_t	RandX::detail::RotL (const std::uint32_t x, const int s) noexcept
static void	RandX::detail::SecureWipe (void *ptr, std::size_t len) noexcept
template<std::size_t N>
static constexpr bool	RandX::detail::IsAllZero (const std::array< std::uint64_t, N > &state) noexcept
template<std::size_t N>
static constexpr bool	RandX::detail::IsAllZero (const std::array< std::uint32_t, N > &state) noexcept
bool	RandX::detail::HardwareRand64 (std::uint64_t &out) noexcept
bool	RandX::detail::GetOsEntropyBytes (void *buf, std::size_t n) noexcept
bool	RandX::detail::HasCryptoGradeOsEntropy () noexcept
static void	RandX::detail::ChaCha20QuarterRound (std::uint32_t &a, std::uint32_t &b, std::uint32_t &c, std::uint32_t &d) noexcept
template<class Engine>
std::uint64_t	RandX::detail::Generate64Bits (Engine &engine)
template<class CharT, class Traits, detail::SerializableEngine Engine>
std::basic_ostream< CharT, Traits > &	RandX::operator<< (std::basic_ostream< CharT, Traits > &os, const Engine &engine)
template<class CharT, class Traits, detail::SerializableEngine Engine>
std::basic_istream< CharT, Traits > &	RandX::operator>> (std::basic_istream< CharT, Traits > &is, Engine &engine)
std::uint64_t	RandX::RandomSeed ()
	生成非确定性的 64 位种子
Xoshiro256StarStar &	RandX::DefaultEngine ()
void	RandX::SecureRandomBytes (void *buf, std::size_t n)
	用 OS 密码学熵源填充 [buf, buf+n) 字节
std::uint64_t	RandX::SecureSeed ()
	生成密码学安全的 64 位随机种子
bool	RandX::IsOsCryptoEntropyAvailable () noexcept
	检测 OS 密码学熵源是否可用
void	RandX::Reseed (std::uint64_t seed)
	重置默认引擎的种子（用于测试复现）
void	RandX::ReseedRandom ()
	重置默认引擎为真随机种子
template<std::integral T = int>
T	RandX::RandInt (T min, T max)
	生成 [min, max] 范围内的随机整数
template<std::integral T = int>
T	RandX::RandInt (T max)
	生成 [0, max] 范围内的随机整数
template<std::floating_point T = double>
T	RandX::RandReal (T min=T{0}, T max=T{1})
	生成 [min, max) 范围内的随机浮点数
bool	RandX::RandBool (double p=0.5)
	生成随机布尔值
template<class Engine>
bool	RandX::RandBool (Engine &engine, double p=0.5)
	生成随机布尔值（指定引擎重载）
bool	RandX::RandBernoulli (double p=0.5)
	伯努利分布（RandBool 的别名封装，对齐 <random> 命名）
template<class Engine>
bool	RandX::RandBernoulli (Engine &engine, double p=0.5)
	伯努利分布（指定引擎重载）
template<detail::Character CharT>
CharT	RandX::RandChar (CharT min, CharT max)
	生成 [min, max] 范围内的随机字符
template<detail::Character CharT = char>
CharT	RandX::RandChar (CharT max)
	生成 [CharT{}, max] 范围内的随机字符
template<detail::Character CharT, class Engine>
CharT	RandX::RandChar (Engine &engine, CharT min, CharT max)
	生成 [min, max] 范围内的随机字符（指定引擎重载）
template<detail::Character CharT = char, class Engine>
CharT	RandX::RandChar (Engine &engine, CharT max)
	生成 [CharT{}, max] 范围内的随机字符（指定引擎重载）
template<class Container> requires std::ranges::random_access_range<Container>
decltype(auto)	RandX::RandElement (Container &c)
	从容器中随机取一个元素（左值容器，返回引用）
template<class Container> requires std::ranges::random_access_range<Container>
std::ranges::range_value_t< Container >	RandX::RandElement (Container &&c)
	从容器中随机取一个元素（右值容器，按值返回以避免悬垂引用）
template<std::random_access_iterator It>
It	RandX::RandElement (It first, It last)
	从迭代器范围内随机取一个元素（随机访问迭代器：O(1) 直接定位）
template<std::input_iterator It> requires (!std::random_access_iterator<It>)
It	RandX::RandElement (It first, It last)
	从迭代器范围内随机取一个元素（输入迭代器：O(n) reservoir sampling）
template<std::random_access_iterator It, class Engine>
It	RandX::RandElement (Engine &engine, It first, It last)
	从迭代器范围内随机取一个元素（指定引擎，随机访问迭代器）
template<std::input_iterator It, class Engine> requires (!std::random_access_iterator<It>)
It	RandX::RandElement (Engine &engine, It first, It last)
	从迭代器范围内随机取一个元素（指定引擎，输入迭代器）
template<std::floating_point T = double>
T	RandX::RandNormal (T mean=T{0}, T stddev=T{1})
	生成正态分布随机数
template<class Engine, std::floating_point T = double>
T	RandX::RandNormal (Engine &engine, T mean=T{0}, T stddev=T{1})
	生成正态分布随机数（指定引擎重载）
template<std::ranges::random_access_range Container>
void	RandX::RandShuffle (Container &&c)
	随机打乱容器
template<class It, class T> requires detail::RandFillable<It, T> && std::integral<T>
void	RandX::RandFill (It first, It last, T min, T max)
	用 [min, max] 范围的随机整数填充迭代器区间
template<class It, std::floating_point T> requires std::output_iterator<It, T>
void	RandX::RandFill (It first, It last, T min, T max)
	用 [min, max) 范围的随机浮点数填充迭代器区间
template<class It, class T, class Engine> requires detail::RandFillable<It, T> && std::integral<T>
void	RandX::RandFill (Engine &engine, It first, It last, T min, T max)
	用 [min, max] 范围的随机整数填充迭代器区间（指定引擎重载）
template<class It, std::floating_point T, class Engine> requires std::output_iterator<It, T>
void	RandX::RandFill (Engine &engine, It first, It last, T min, T max)
	用 [min, max) 范围的随机浮点数填充迭代器区间（指定引擎重载）
template<std::integral T = int>
std::vector< T >	RandX::RandVector (T min, T max, std::size_t n)
	生成含 n 个随机整数的 vector
template<std::floating_point T = double>
std::vector< T >	RandX::RandVector (T min, T max, std::size_t n)
	生成含 n 个随机浮点数的 vector
template<std::integral T = int, class Engine>
std::vector< T >	RandX::RandVector (Engine &engine, T min, T max, std::size_t n)
	生成含 n 个随机整数的 vector（指定引擎重载）
template<std::floating_point T = double, class Engine>
std::vector< T >	RandX::RandVector (Engine &engine, T min, T max, std::size_t n)
	生成含 n 个随机浮点数的 vector（指定引擎重载）
template<class WeightContainer>
WeightContainer::size_type	RandX::RandWeighted (const WeightContainer &weights)
	按权重随机选取索引
template<class Engine, class WeightContainer>
WeightContainer::size_type	RandX::RandWeighted (Engine &engine, const WeightContainer &weights)
	按权重随机选取索引（指定引擎重载）
template<class IntType>
IntType	RandX::RandWeighted (std::discrete_distribution< IntType > &dist)
	按预构建权重分布随机选取索引（支持高频抽取复用，O(1) 复杂度）
template<class Engine, class IntType>
IntType	RandX::RandWeighted (Engine &engine, std::discrete_distribution< IntType > &dist)
	按预构建权重分布随机选取索引（指定引擎，支持高频抽取复用，O(1) 复杂度）
template<std::integral T, class Engine>
T	RandX::RandInt (Engine &engine, T min, T max)
	生成 [min, max] 范围内的随机整数（指定引擎重载）
template<std::floating_point T, class Engine>
T	RandX::RandReal (Engine &engine, T min=T{0}, T max=T{1})
	生成 [min, max) 范围内的随机浮点数（指定引擎重载）
constexpr std::uint64_t	RandX::detail::BoundedRand (Xoshiro256StarStar &rng, std::uint64_t range) noexcept
std::string_view	RandX::detail::CharSetString (CharSet cs) noexcept
char	RandX::RandChar (CharSet cs)
	从预设字符集随机取一个字符
template<class Engine>
char	RandX::RandChar (Engine &engine, CharSet cs)
	从预设字符集随机取一个字符（指定引擎重载）
template<std::ranges::random_access_range Container>
auto	RandX::RandSample (const Container &c, typename Container::size_type n)
	无放回抽样：从容器中随机抽取 n 个元素（Fisher-Yates 前 n 步）
template<std::random_access_iterator It>
std::vector< std::iter_value_t< It > >	RandX::RandSample (It first, It last, std::iter_difference_t< It > n)
	无放回抽样（随机访问迭代器版，hash-set / 索引数组双分支）
template<std::input_iterator It> requires (!std::random_access_iterator<It>)
std::vector< std::iter_value_t< It > >	RandX::RandSample (It first, It last, std::iter_difference_t< It > n)
	无放回抽样（输入迭代器版，reservoir sampling Algorithm R）
template<std::random_access_iterator It, class Engine>
std::vector< std::iter_value_t< It > >	RandX::RandSample (Engine &engine, It first, It last, std::iter_difference_t< It > n)
	无放回抽样（指定引擎，随机访问迭代器版）
template<std::input_iterator It, class Engine> requires (!std::random_access_iterator<It>)
std::vector< std::iter_value_t< It > >	RandX::RandSample (Engine &engine, It first, It last, std::iter_difference_t< It > n)
	无放回抽样（指定引擎，输入迭代器版，reservoir sampling）
std::vector< std::size_t >	RandX::RandPermutation (std::size_t n)
	生成 [0, n) 的随机排列
std::string	RandX::RandString (std::size_t length, std::string_view charset="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
	生成指定长度的随机字符串
std::string	RandX::RandString (std::size_t n, CharSet cs)
	从预设字符集生成随机字符串
template<class Engine>
std::string	RandX::RandString (Engine &engine, std::size_t n, CharSet cs)
	从预设字符集生成随机字符串（指定引擎重载）
template<std::floating_point T = double>
T	RandX::RandExp (T lambda=T{1})
	生成指数分布随机数
template<class Engine, std::floating_point T = double>
T	RandX::RandExp (Engine &engine, T lambda=T{1})
	生成指数分布随机数（指定引擎重载）
template<std::integral T = int>
T	RandX::RandPoisson (double mean=1.0)
	生成泊松分布随机数
template<class Engine, std::integral T = int>
T	RandX::RandPoisson (Engine &engine, double mean=1.0)
	生成泊松分布随机数（指定引擎重载）
template<std::floating_point T = double>
T	RandX::RandGamma (T alpha=T{1}, T beta=T{1})
	生成伽马分布随机数
template<class Engine, std::floating_point T = double>
T	RandX::RandGamma (Engine &engine, T alpha=T{1}, T beta=T{1})
	生成伽马分布随机数（指定引擎重载）
template<std::integral T = int>
T	RandX::RandBinomial (T t=1, double p=0.5)
	生成二项分布随机数
template<std::integral T = int, class Engine>
T	RandX::RandBinomial (Engine &engine, T t=1, double p=0.5)
	生成二项分布随机数（指定引擎重载）
template<std::floating_point T = double>
T	RandX::RandLogNormal (T mean=T{0}, T stddev=T{1})
	生成对数正态分布随机数
template<std::floating_point T = double, class Engine>
T	RandX::RandLogNormal (Engine &engine, T mean=T{0}, T stddev=T{1})
	生成对数正态分布随机数（指定引擎重载）
template<std::integral T = int>
T	RandX::RandGeometric (double p=0.5)
	生成几何分布随机数（首次成功前的失败次数）
template<std::integral T = int, class Engine>
T	RandX::RandGeometric (Engine &engine, double p=0.5)
	生成几何分布随机数（指定引擎重载）
template<std::floating_point T = double>
T	RandX::RandCauchy (T a=T{0}, T b=T{1})
	生成柯西分布随机数
template<std::floating_point T = double, class Engine>
T	RandX::RandCauchy (Engine &engine, T a=T{0}, T b=T{1})
	生成柯西分布随机数（指定引擎重载）
template<std::floating_point T = double>
T	RandX::RandWeibull (T a=T{1}, T b=T{1})
	生成韦布尔分布随机数
template<std::floating_point T = double, class Engine>
T	RandX::RandWeibull (Engine &engine, T a=T{1}, T b=T{1})
	生成韦布尔分布随机数（指定引擎重载）
template<std::floating_point T = double>
T	RandX::RandExtremeValue (T a=T{0}, T b=T{1})
	生成极值分布（Gumbel）随机数
template<std::floating_point T = double, class Engine>
T	RandX::RandExtremeValue (Engine &engine, T a=T{0}, T b=T{1})
	生成极值分布随机数（指定引擎重载）
template<std::floating_point T = double>
T	RandX::RandChiSquared (T n=T{1})
	生成卡方分布随机数
template<std::floating_point T = double, class Engine>
T	RandX::RandChiSquared (Engine &engine, T n=T{1})
	生成卡方分布随机数（指定引擎重载）
template<std::floating_point T = double>
T	RandX::RandStudentT (T n=T{1})
	生成学生 t 分布随机数
template<std::floating_point T = double, class Engine>
T	RandX::RandStudentT (Engine &engine, T n=T{1})
	生成学生 t 分布随机数（指定引擎重载）
template<std::floating_point T = double>
T	RandX::RandFisherF (T m=T{1}, T n=T{1})
	生成 Fisher F 分布随机数
template<std::floating_point T = double, class Engine>
T	RandX::RandFisherF (Engine &engine, T m=T{1}, T n=T{1})
	生成 Fisher F 分布随机数（指定引擎重载）
template<std::floating_point T = double>
T	RandX::RandBeta (T a=T{1}, T b=T{1})
	生成 Beta 分布随机数
template<std::floating_point T = double, class Engine>
T	RandX::RandBeta (Engine &engine, T a=T{1}, T b=T{1})
	生成 Beta 分布随机数（指定引擎重载）
template<int N, std::integral T = std::uint64_t> requires (N > 0 && N <= 64 && N <= std::numeric_limits<T>::digits)
T	RandX::RandBits () noexcept
	生成 N 位随机整数
template<class Engine>
std::string	RandX::RandUUID (Engine &engine)
	生成随机 UUID v4 字符串
std::string	RandX::RandUUID ()
template<class Engine> requires detail::StreamEngine<Engine>
constexpr Engine	RandX::MakeStreamEngine (std::uint64_t streamId, std::uint64_t seed=DefaultSeed)
	从同一种子创建第 streamId 个不重叠子序列的引擎
template<std::integral T = int, std::uint64_t Seed = DefaultSeed>
constexpr T	RandX::RandIntCE (T min, T max)
	编译期生成 [min, max] 范围内的随机整数
template<std::integral T = int, std::uint64_t Seed = DefaultSeed>
constexpr T	RandX::RandIntCE (T max)
	编译期生成 [0, max] 范围内的随机整数
template<std::random_access_iterator It, std::uint64_t Seed = DefaultSeed>
constexpr void	RandX::ShuffleCE (It first, It last) noexcept
	编译期 Fisher-Yates 洗牌
template<class T, std::size_t N, std::uint64_t Seed = DefaultSeed>
constexpr std::array< T, N >	RandX::ShuffledArray (std::array< T, N > arr) noexcept
	编译期洗牌数组版本（返回打乱后的副本）
template<std::ranges::input_range R> requires std::ranges::sized_range<R> \|\| std::ranges::forward_range<R>
std::ranges::range_value_t< R >	RandX::ranges::RandElement (R &&r)
	随机选取一个元素（返回值拷贝，非迭代器）
template<std::ranges::input_range R>
std::vector< std::ranges::range_value_t< R > >	RandX::ranges::RandSample (R &&r, std::ranges::range_difference_t< R > n)
	无放回抽样（复用迭代器版实现，自动选择 random_access / input 路径）
template<std::ranges::random_access_range R> requires std::ranges::sized_range<R>
void	RandX::ranges::RandShuffle (R &&r)
	随机打乱 range（要求 random_access + sized）
template<class T, std::ranges::output_range< const T & > R>
void	RandX::ranges::RandFill (R &&r, T min, T max)
	用随机数填充 range

变量
constexpr std::uint64_t	RandX::DefaultSeed = 1234567890ULL
constexpr std::uint32_t	RandX::detail::ChaCha20Constants [4]
constexpr std::uint64_t	RandX::detail::ChaCha20ReseedThreshold = 1ULL << 20
constexpr std::uint64_t	RandX::detail::HashSetThresholdK = 64

类

命名空间

概念

枚举

函数

变量