命名空间
namespace	detail
namespace	ranges

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

枚举
enum class	CharSet { CharSet::Alphanumeric , CharSet::Alpha , CharSet::Lower , CharSet::Upper , CharSet::Digit , CharSet::Hex , CharSet::Printable , CharSet::Base64 , CharSet::Base64UrlSafe , CharSet::Alphanumeric , CharSet::Alpha , CharSet::Lower , CharSet::Upper , CharSet::Digit , CharSet::Hex , CharSet::Printable , CharSet::Base64 , CharSet::Base64UrlSafe }
enum class	CharSet { Alphanumeric , Alpha , Lower , Upper , Digit , Hex , Printable , Base64 , Base64UrlSafe , Alphanumeric , Alpha , Lower , Upper , Digit , Hex , Printable , Base64 , Base64UrlSafe }

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

变量
constexpr std::uint64_t	DefaultSeed = 1234567890ULL

枚举类型说明

◆ CharSet

enum class RandX::CharSet

strong

枚举值
Alphanumeric
Alpha
Lower
Upper
Digit
Hex
Printable
Base64
Base64UrlSafe
Alphanumeric
Alpha
Lower
Upper
Digit
Hex
Printable
Base64
Base64UrlSafe

函数说明

◆ DoubleFromBits()

template<class Uint64, std::enable_if_t< std::is_same_v< Uint64, std::uint64_t > > * = nullptr>

double RandX::DoubleFromBits ( Uint64 i )

inlinenodiscardconstexprnoexcept

◆ FloatFromBits()

template<class Uint32, std::enable_if_t< std::is_same_v< Uint32, std::uint32_t > > * = nullptr>

float RandX::FloatFromBits ( Uint32 i )

inlinenodiscardconstexprnoexcept

◆ MakeStreamEngine()

template<class Engine, std::enable_if_t< detail::HasJump< Engine >::value > * = nullptr>

Engine RandX::MakeStreamEngine	(	std::uint64_t	streamId,
		std::uint64_t	seed = DefaultSeed )

inlinenodiscardconstexpr

◆ operator<<()

template<class CharT, class Traits, class Engine, std::enable_if_t< detail::is_serializable_engine_v< Engine > > * = nullptr>

std::basic_ostream< CharT, Traits > & RandX::operator<<	(	std::basic_ostream< CharT, Traits > &	os,
		const Engine &	engine )

函数调用图:

◆ operator>>()

template<class CharT, class Traits, class Engine, std::enable_if_t< detail::is_serializable_engine_v< Engine > > * = nullptr>

std::basic_istream< CharT, Traits > & RandX::operator>>	(	std::basic_istream< CharT, Traits > &	is,
		Engine &	engine )

函数调用图:

◆ RandBeta() [1/2]

template<class T = double, class Engine, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandBeta	(	Engine &	engine,
		T	a = T{1},
		T	b = T{1} )

inlinenodiscard

生成 Beta 分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
a	形状参数（默认 1）
b	形状参数（默认 1）

返回: 服从 Beta(a, b) 的随机数

函数调用图:

◆ RandBeta() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandBeta	(	T	a = T{1},
		T	b = T{1} )

inlinenodiscard

生成 Beta 分布随机数

参数

a	形状参数（默认 1）
b	形状参数（默认 1）

返回: 服从 Beta(a, b) 的随机数

注解: 无 STL 对应，自实现 Gamma(a)/(Gamma(a)+Gamma(b))

函数调用图:

◆ RandBinomial() [1/2]

template<class T = int, class Engine, std::enable_if_t< std::is_integral_v< T > > * = nullptr>

T RandX::RandBinomial	(	Engine &	engine,
		T	t = 1,
		double	p = 0.5 )

inlinenodiscard

生成二项分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
t	试验次数（默认 1）
p	每次成功概率（默认 0.5）

返回: 服从 B(t, p) 的随机整数

函数调用图:

◆ RandBinomial() [2/2]

template<class T = int, std::enable_if_t< std::is_integral_v< T > > * = nullptr>

T RandX::RandBinomial	(	T	t = 1,
		double	p = 0.5 )

inlinenodiscard

生成二项分布随机数

参数

t	试验次数（默认 1）
p	每次成功概率（默认 0.5）

返回: 服从 B(t, p) 的随机整数

函数调用图:

◆ RandBits()

template<int N, class T = std::uint64_t, std::enable_if_t< std::is_integral_v< T > &&(N > 0) &&(N<=64) &&(N<=std::numeric_limits< T >::digits)> * = nullptr>

T RandX::RandBits ( )

inlinenodiscardnoexcept

生成 N 位随机整数

模板参数

N	位数（1-64，且不超过 T 的位宽）

返回: 均匀分布于 [0, 2^N) 的随机整数

函数调用图:

◆ RandCauchy() [1/2]

template<class T = double, class Engine, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandCauchy	(	Engine &	engine,
		T	a = T{0},
		T	b = T{1} )

inlinenodiscard

生成柯西分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
a	位置参数（默认 0）
b	尺度参数（默认 1）

返回: 服从 Cauchy(a, b) 的随机数

函数调用图:

◆ RandCauchy() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandCauchy	(	T	a = T{0},
		T	b = T{1} )

inlinenodiscard

生成柯西分布随机数

参数

a	位置参数（默认 0）
b	尺度参数（默认 1）

返回: 服从 Cauchy(a, b) 的随机数

函数调用图:

◆ RandChar() [1/4]

template<class CharT, std::enable_if_t< detail::is_character_v< CharT > > * = nullptr>

CharT RandX::RandChar ( CharT max )

inlinenodiscard

生成 [CharT{}, max] 范围内的随机字符

参数

max 上界字符（含）

返回: 均匀分布于 [CharT{}, max] 的随机字符

函数调用图:

◆ RandChar() [2/4]

template<class CharT, std::enable_if_t< detail::is_character_v< CharT > > * = nullptr>

CharT RandX::RandChar	(	CharT	min,
		CharT	max )

inlinenodiscard

生成 [min, max] 范围内的随机字符

参数

min	下界字符（含）
max	上界字符（含）

返回: 均匀分布于 [min, max] 的随机字符

注解: 内部用 int64_t 避免 char32_t 范围（最大 0xFFFFFFFF）溢出 int32_t

函数调用图:

◆ RandChar() [3/4]

template<class CharT, class Engine, std::enable_if_t< detail::is_character_v< CharT > > * = nullptr>

CharT RandX::RandChar	(	Engine &	engine,
		CharT	max )

inlinenodiscard

生成 [CharT{}, max] 范围内的随机字符（指定引擎重载）

参数

engine	自定义随机数引擎
max	上界字符（含）

返回: 均匀分布于 [CharT{}, max] 的随机字符

函数调用图:

◆ RandChar() [4/4]

template<class CharT, class Engine, std::enable_if_t< detail::is_character_v< CharT > > * = nullptr>

CharT RandX::RandChar	(	Engine &	engine,
		CharT	min,
		CharT	max )

inlinenodiscard

生成 [min, max] 范围内的随机字符（指定引擎重载）

参数

engine	自定义随机数引擎
min	下界字符（含）
max	上界字符（含）

返回: 均匀分布于 [min, max] 的随机字符

函数调用图:

◆ RandChiSquared() [1/2]

template<class T = double, class Engine, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandChiSquared	(	Engine &	engine,
		T	n = T{1} )

inlinenodiscard

生成卡方分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
n	自由度（默认 1）

返回: 服从 ChiSquared(n) 的随机数

函数调用图:

◆ RandChiSquared() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandChiSquared ( T n = T{1} )

inlinenodiscard

生成卡方分布随机数

参数

n 自由度（默认 1）

返回: 服从 ChiSquared(n) 的随机数

函数调用图:

◆ RandElement() [1/8]

template<class Container, std::enable_if_t< detail::is_random_access_container_v< std::decay_t< Container > > > * = nullptr>

std::decay_t< Container >::value_type RandX::RandElement ( Container && c )

inlinenodiscard

从容器中随机取一个元素（右值容器，按值返回以避免悬垂引用）

参数

c	源容器（需支持 operator[] 和 size()）

返回: 容器中随机选取的一个元素的副本

异常

std::invalid_argument 容器为空时抛出

函数调用图:

◆ RandElement() [2/8]

template<class Container, std::enable_if_t< detail::is_random_access_container_v< Container > > * = nullptr>

decltype(auto) RandX::RandElement ( Container & c )

inlinenodiscard

从容器中随机取一个元素（左值容器，返回引用）

参数

c	源容器（需支持 operator[] 和 size()）

返回: 容器中随机选取的一个元素的引用

异常

std::invalid_argument 容器为空时抛出

函数调用图:

◆ RandElement() [3/8]

template<std::input_iterator It, class Engine>
requires (!std::random_access_iterator<It>)

It RandX::RandElement	(	Engine &	engine,
		It	first,
		It	last )

inlinenodiscard

从迭代器范围内随机取一个元素（指定引擎，输入迭代器）

参数

engine	自定义随机数引擎
first	范围起始迭代器
last	范围结束迭代器

返回: 指向随机选取元素的迭代器

函数调用图:

◆ RandElement() [4/8]

template<class It, class Engine, std::enable_if_t< detail::is_input_iterator_v< It > &&!detail::is_random_access_iterator_v< It > > * = nullptr>

It RandX::RandElement	(	Engine &	engine,
		It	first,
		It	last )

inlinenodiscard

从迭代器范围内随机取一个元素（指定引擎，输入迭代器）

参数

engine	自定义随机数引擎
first	范围起始迭代器
last	范围结束迭代器

返回: 指向随机选取元素的迭代器

函数调用图:

◆ RandElement() [5/8]

template<class It, class Engine, std::enable_if_t< detail::is_random_access_iterator_v< It > > * = nullptr>

It RandX::RandElement	(	Engine &	engine,
		It	first,
		It	last )

inlinenodiscard

从迭代器范围内随机取一个元素（指定引擎，随机访问迭代器）

参数

engine	自定义随机数引擎
first	范围起始迭代器
last	范围结束迭代器

返回: 指向随机选取元素的迭代器

函数调用图:

◆ RandElement() [6/8]

template<std::input_iterator It>
requires (!std::random_access_iterator<It>)

It RandX::RandElement	(	It	first,
		It	last )

inlinenodiscard

从迭代器范围内随机取一个元素（输入迭代器：O(n) reservoir sampling）

参数

first	范围起始迭代器
last	范围结束迭代器

返回: 指向随机选取元素的迭代器

异常

std::invalid_argument 范围为空时抛出

函数调用图:

◆ RandElement() [7/8]

template<class It, std::enable_if_t< detail::is_input_iterator_v< It > &&!detail::is_random_access_iterator_v< It > > * = nullptr>

It RandX::RandElement	(	It	first,
		It	last )

inlinenodiscard

从迭代器范围内随机取一个元素（输入迭代器：O(n) reservoir sampling）

参数

first	范围起始迭代器
last	范围结束迭代器

返回: 指向随机选取元素的迭代器

异常

std::invalid_argument 范围为空时抛出

函数调用图:

◆ RandElement() [8/8]

template<class It, std::enable_if_t< detail::is_random_access_iterator_v< It > > * = nullptr>

It RandX::RandElement	(	It	first,
		It	last )

inlinenodiscard

从迭代器范围内随机取一个元素（随机访问迭代器：O(1) 直接定位）

参数

first	范围起始迭代器
last	范围结束迭代器

返回: 指向随机选取元素的迭代器

异常

std::invalid_argument 范围为空时抛出

函数调用图:

◆ RandExp() [1/2]

template<class Engine, class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandExp	(	Engine &	engine,
		T	lambda = T{1} )

inlinenodiscard

生成指数分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
lambda	速率参数（默认 1，均值 = 1/lambda）

返回: 服从 Exp(lambda) 的随机数

函数调用图:

◆ RandExp() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandExp ( T lambda = T{1} )

inlinenodiscard

生成指数分布随机数

参数

lambda 速率参数（默认 1，均值 = 1/lambda）

返回: 服从 Exp(lambda) 的随机数

函数调用图:

◆ RandExtremeValue() [1/2]

template<class T = double, class Engine, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandExtremeValue	(	Engine &	engine,
		T	a = T{0},
		T	b = T{1} )

inlinenodiscard

生成极值分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
a	位置参数（默认 0）
b	尺度参数（默认 1）

返回: 服从 ExtremeValue(a, b) 的随机数

函数调用图:

◆ RandExtremeValue() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandExtremeValue	(	T	a = T{0},
		T	b = T{1} )

inlinenodiscard

生成极值分布（Gumbel）随机数

参数

a	位置参数（默认 0）
b	尺度参数（默认 1）

返回: 服从 ExtremeValue(a, b) 的随机数

函数调用图:

◆ RandFill() [1/4]

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 )

inline

用 [min, max) 范围的随机浮点数填充迭代器区间（指定引擎重载）

参数

engine	自定义随机数引擎
first	起始迭代器
last	结束迭代器
min	随机数下界（含）
max	随机数上界（不含）

◆ RandFill() [2/4]

template<class It, class T, class Engine, std::enable_if_t< detail::is_rand_fillable_v< It, T > > * = nullptr>

void RandX::RandFill	(	Engine &	engine,
		It	first,
		It	last,
		T	min,
		T	max )

inline

用 [min, max] 范围的随机整数填充迭代器区间（指定引擎重载）

参数

engine	自定义随机数引擎
first	起始迭代器
last	结束迭代器
min	随机数下界（含）
max	随机数上界（含）

函数调用图:

◆ RandFill() [3/4]

template<class It, std::floating_point T>
requires std::output_iterator<It, T>

void RandX::RandFill	(	It	first,
		It	last,
		T	min,
		T	max )

inline

用 [min, max) 范围的随机浮点数填充迭代器区间

参数

first	起始迭代器
last	结束迭代器
min	随机数下界（含）
max	随机数上界（不含）

函数调用图:

◆ RandFill() [4/4]

template<class It, class T, std::enable_if_t< detail::is_rand_fillable_v< It, T > > * = nullptr>

void RandX::RandFill	(	It	first,
		It	last,
		T	min,
		T	max )

inline

用 [min, max] 范围的随机整数填充迭代器区间

参数

first	起始迭代器
last	结束迭代器
min	随机数下界（含）
max	随机数上界（含）

注解: T 从 min/max 推导，不从迭代器 value_type 推导。若容器元素类型与 min/max 字面量类型不一致，需显式指定 T 或用匹配类型的字面量。

函数调用图:

◆ RandFisherF() [1/2]

template<class T = double, class Engine, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandFisherF	(	Engine &	engine,
		T	m = T{1},
		T	n = T{1} )

inlinenodiscard

生成 Fisher F 分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
m	第一自由度（默认 1）
n	第二自由度（默认 1）

返回: 服从 FisherF(m, n) 的随机数

函数调用图:

◆ RandFisherF() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandFisherF	(	T	m = T{1},
		T	n = T{1} )

inlinenodiscard

生成 Fisher F 分布随机数

参数

m	第一自由度（默认 1）
n	第二自由度（默认 1）

返回: 服从 FisherF(m, n) 的随机数

函数调用图:

◆ RandGamma() [1/2]

template<class Engine, class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandGamma	(	Engine &	engine,
		T	alpha = T{1},
		T	beta = T{1} )

inlinenodiscard

生成伽马分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
alpha	形状参数（默认 1）
beta	尺度参数（默认 1）

返回: 服从 Gamma(alpha, beta) 的随机数

函数调用图:

◆ RandGamma() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandGamma	(	T	alpha = T{1},
		T	beta = T{1} )

inlinenodiscard

生成伽马分布随机数

参数

alpha	形状参数（默认 1）
beta	尺度参数（默认 1）

返回: 服从 Gamma(alpha, beta) 的随机数

函数调用图:

◆ RandGeometric() [1/2]

template<class T = int, std::enable_if_t< std::is_integral_v< T > > * = nullptr>

T RandX::RandGeometric ( double p = 0.5 )

inlinenodiscard

生成几何分布随机数（首次成功前的失败次数）

参数

p	每次成功概率（默认 0.5）

返回: 服从 Geometric(p) 的随机整数

函数调用图:

◆ RandGeometric() [2/2]

template<class T = int, class Engine, std::enable_if_t< std::is_integral_v< T > > * = nullptr>

T RandX::RandGeometric	(	Engine &	engine,
		double	p = 0.5 )

inlinenodiscard

生成几何分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
p	每次成功概率（默认 0.5）

返回: 服从 Geometric(p) 的随机整数

函数调用图:

◆ RandInt() [1/3]

template<class T, class Engine, std::enable_if_t< std::is_integral_v< T > > * = nullptr>

T RandX::RandInt	(	Engine &	engine,
		T	min,
		T	max )

inlinenodiscard

生成 [min, max] 范围内的随机整数（指定引擎重载）

参数

engine	自定义随机数引擎
min	下界（含）
max	上界（含）

返回: 均匀分布于 [min, max] 的随机整数

函数调用图:

◆ RandInt() [2/3]

template<class T = int, std::enable_if_t< std::is_integral_v< T > > * = nullptr>

T RandX::RandInt ( T max )

inlinenodiscard

生成 [0, max] 范围内的随机整数

参数

max 上界（含）

返回: 均匀分布于 [0, max] 的随机整数

函数调用图:

◆ RandInt() [3/3]

template<class T = int, std::enable_if_t< std::is_integral_v< T > > * = nullptr>

T RandX::RandInt	(	T	min,
		T	max )

inlinenodiscard

生成 [min, max] 范围内的随机整数

参数

min	下界（含）
max	上界（含）

返回: 均匀分布于 [min, max] 的随机整数

函数调用图:

◆ RandLogNormal() [1/2]

template<class T = double, class Engine, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandLogNormal	(	Engine &	engine,
		T	mean = T{0},
		T	stddev = T{1} )

inlinenodiscard

生成对数正态分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
mean	对数均值（默认 0）
stddev	对数标准差（默认 1）

返回: 服从 LogNormal(mean, stddev) 的随机数

函数调用图:

◆ RandLogNormal() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandLogNormal	(	T	mean = T{0},
		T	stddev = T{1} )

inlinenodiscard

生成对数正态分布随机数

参数

mean	对数均值（默认 0）
stddev	对数标准差（默认 1）

返回: 服从 LogNormal(mean, stddev) 的随机数

函数调用图:

◆ RandNormal() [1/2]

template<class Engine, class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandNormal	(	Engine &	engine,
		T	mean = T{0},
		T	stddev = T{1} )

inlinenodiscard

生成正态分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
mean	均值（默认 0）
stddev	标准差（默认 1）

返回: 服从 N(mean, stddev) 的随机数

函数调用图:

◆ RandNormal() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandNormal	(	T	mean = T{0},
		T	stddev = T{1} )

inlinenodiscard

生成正态分布随机数

参数

mean	均值（默认 0）
stddev	标准差（默认 1）

返回: 服从 N(mean, stddev) 的随机数

函数调用图:

◆ RandPoisson() [1/2]

template<class T = int, std::enable_if_t< std::is_integral_v< T > > * = nullptr>

T RandX::RandPoisson ( double mean = 1.0 )

inlinenodiscard

生成泊松分布随机数

参数

mean	均值参数（默认 1.0）

返回: 服从 Poisson(mean) 的随机整数

函数调用图:

◆ RandPoisson() [2/2]

template<class Engine, class T = int, std::enable_if_t< std::is_integral_v< T > > * = nullptr>

T RandX::RandPoisson	(	Engine &	engine,
		double	mean = 1.0 )

inlinenodiscard

生成泊松分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
mean	均值参数（默认 1.0）

返回: 服从 Poisson(mean) 的随机整数

函数调用图:

◆ RandReal() [1/2]

template<class T, class Engine, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandReal	(	Engine &	engine,
		T	min = T{0},
		T	max = T{1} )

inlinenodiscard

生成 [min, max) 范围内的随机浮点数（指定引擎重载）

参数

engine	自定义随机数引擎
min	下界（含，默认 0）
max	上界（不含，默认 1）

返回: 均匀分布于 [min, max) 的随机浮点数

函数调用图:

◆ RandReal() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandReal	(	T	min = T{0},
		T	max = T{1} )

inlinenodiscard

生成 [min, max) 范围内的随机浮点数

参数

min	下界（含，默认 0）
max	上界（不含，默认 1）

返回: 均匀分布于 [min, max) 的随机浮点数

函数调用图:

◆ RandSample() [1/7]

template<class Container, std::enable_if_t< detail::is_random_access_container_v< Container > > * = nullptr>

auto RandX::RandSample	(	const Container &	c,
		typename Container::size_type	n )

inlinenodiscard

无放回抽样：从容器中随机抽取 n 个元素（Fisher-Yates 前 n 步）

参数

c	源容器
n	抽取数量（若 n >= 容器大小则返回全部元素的副本）

返回: 含 n 个随机选取元素的 vector

函数调用图:

◆ RandSample() [2/7]

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 )

inlinenodiscard

无放回抽样（指定引擎，输入迭代器版，reservoir sampling）

参数

engine	自定义随机数引擎
first	范围起始迭代器
last	范围结束迭代器
n	抽取数量

返回: 含 n 个随机选取元素的 vector

函数调用图:

◆ RandSample() [3/7]

template<class It, class Engine, std::enable_if_t< detail::is_input_iterator_v< It > &&!detail::is_random_access_iterator_v< It > > * = nullptr>

std::vector< typename std::iterator_traits< It >::value_type > RandX::RandSample	(	Engine &	engine,
		It	first,
		It	last,
		typename std::iterator_traits< It >::difference_type	n )

inlinenodiscard

函数调用图:

◆ RandSample() [4/7]

template<class It, class Engine, std::enable_if_t< detail::is_random_access_iterator_v< It > > * = nullptr>

std::vector< typename std::iterator_traits< It >::value_type > RandX::RandSample	(	Engine &	engine,
		It	first,
		It	last,
		typename std::iterator_traits< It >::difference_type	n )

inlinenodiscard

函数调用图:

◆ RandSample() [5/7]

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 )

inlinenodiscard

无放回抽样（输入迭代器版，reservoir sampling Algorithm R）

参数

first	范围起始迭代器
last	范围结束迭代器
n	抽取数量

返回: 含 n 个随机选取元素的 vector

函数调用图:

◆ RandSample() [6/7]

template<class It, std::enable_if_t< detail::is_input_iterator_v< It > &&!detail::is_random_access_iterator_v< It > > * = nullptr>

std::vector< typename std::iterator_traits< It >::value_type > RandX::RandSample	(	It	first,
		It	last,
		typename std::iterator_traits< It >::difference_type	n )

inlinenodiscard

函数调用图:

◆ RandSample() [7/7]

template<class It, std::enable_if_t< detail::is_random_access_iterator_v< It > > * = nullptr>

std::vector< typename std::iterator_traits< It >::value_type > RandX::RandSample	(	It	first,
		It	last,
		typename std::iterator_traits< It >::difference_type	n )

inlinenodiscard

函数调用图:

◆ RandShuffle()

template<class Container, std::enable_if_t< detail::is_random_access_container_v< Container > > * = nullptr>

void RandX::RandShuffle ( Container && c )

inline

随机打乱容器

参数

c 待打乱的容器

函数调用图:

◆ RandStudentT() [1/2]

template<class T = double, class Engine, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandStudentT	(	Engine &	engine,
		T	n = T{1} )

inlinenodiscard

生成学生 t 分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
n	自由度（默认 1）

返回: 服从 StudentT(n) 的随机数

函数调用图:

◆ RandStudentT() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandStudentT ( T n = T{1} )

inlinenodiscard

生成学生 t 分布随机数

参数

n 自由度（默认 1）

返回: 服从 StudentT(n) 的随机数

函数调用图:

◆ RandVector() [1/6]

template<std::floating_point T = double, class Engine>

std::vector< T > RandX::RandVector	(	Engine &	engine,
		T	min,
		T	max,
		std::size_t	n )

inlinenodiscard

生成含 n 个随机浮点数的 vector（指定引擎重载）

参数

engine	自定义随机数引擎
min	随机数下界（含）
max	随机数上界（不含）
n	生成数量

返回: 含 n 个均匀分布于 [min, max) 的随机浮点数 vector

◆ RandVector() [2/6]

template<class T, class Engine, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

std::vector< T > RandX::RandVector	(	Engine &	engine,
		T	min,
		T	max,
		std::size_t	n )

inlinenodiscard

生成含 n 个随机浮点数的 vector（指定引擎重载）

参数

engine	自定义随机数引擎
min	随机数下界（含）
max	随机数上界（不含）
n	生成数量

返回: 含 n 个均匀分布于 [min, max) 的随机浮点数 vector

函数调用图:

◆ RandVector() [3/6]

template<class T, class Engine, std::enable_if_t< std::is_integral_v< T > > * = nullptr>

std::vector< T > RandX::RandVector	(	Engine &	engine,
		T	min,
		T	max,
		std::size_t	n )

inlinenodiscard

生成含 n 个随机整数的 vector（指定引擎重载）

参数

engine	自定义随机数引擎
min	随机数下界（含）
max	随机数上界（含）
n	生成数量

返回: 含 n 个均匀分布于 [min, max] 的随机整数 vector

函数调用图:

◆ RandVector() [4/6]

template<std::floating_point T = double>

std::vector< T > RandX::RandVector	(	T	min,
		T	max,
		std::size_t	n )

inlinenodiscard

生成含 n 个随机浮点数的 vector

参数

min	随机数下界（含）
max	随机数上界（不含）
n	生成数量

返回: 含 n 个均匀分布于 [min, max) 的随机浮点数 vector

函数调用图:

◆ RandVector() [5/6]

template<class T, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

std::vector< T > RandX::RandVector	(	T	min,
		T	max,
		std::size_t	n )

inlinenodiscard

生成含 n 个随机浮点数的 vector

参数

min	随机数下界（含）
max	随机数上界（不含）
n	生成数量

返回: 含 n 个均匀分布于 [min, max) 的随机浮点数 vector

函数调用图:

◆ RandVector() [6/6]

template<class T, std::enable_if_t< std::is_integral_v< T > > * = nullptr>

std::vector< T > RandX::RandVector	(	T	min,
		T	max,
		std::size_t	n )

inlinenodiscard

生成含 n 个随机整数的 vector

参数

min	随机数下界（含）
max	随机数上界（含）
n	生成数量

返回: 含 n 个均匀分布于 [min, max] 的随机整数 vector

函数调用图:

◆ RandWeibull() [1/2]

template<class T = double, class Engine, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandWeibull	(	Engine &	engine,
		T	a = T{1},
		T	b = T{1} )

inlinenodiscard

生成韦布尔分布随机数（指定引擎重载）

参数

engine	自定义随机数引擎
a	形状参数（默认 1）
b	尺度参数（默认 1）

返回: 服从 Weibull(a, b) 的随机数

函数调用图:

◆ RandWeibull() [2/2]

template<class T = double, std::enable_if_t< std::is_floating_point_v< T > > * = nullptr>

T RandX::RandWeibull	(	T	a = T{1},
		T	b = T{1} )

inlinenodiscard

生成韦布尔分布随机数

参数

a	形状参数（默认 1）
b	尺度参数（默认 1）

返回: 服从 Weibull(a, b) 的随机数

函数调用图:

变量说明

◆ DefaultSeed

std::uint64_t RandX::DefaultSeed = 1234567890ULL

inlineconstexpr

命名空间

类

枚举

函数

变量

枚举类型说明

◆ CharSet

函数说明

◆ DoubleFromBits()

◆ FloatFromBits()

◆ MakeStreamEngine()

◆ operator<<()

◆ operator>>()

◆ RandBeta() [1/2]

◆ RandBeta() [2/2]

◆ RandBinomial() [1/2]

◆ RandBinomial() [2/2]

◆ RandBits()

◆ RandCauchy() [1/2]

◆ RandCauchy() [2/2]

◆ RandChar() [1/4]

◆ RandChar() [2/4]

◆ RandChar() [3/4]

◆ RandChar() [4/4]

◆ RandChiSquared() [1/2]

◆ RandChiSquared() [2/2]

◆ RandElement() [1/8]

◆ RandElement() [2/8]

◆ RandElement() [3/8]

◆ RandElement() [4/8]

◆ RandElement() [5/8]

◆ RandElement() [6/8]

◆ RandElement() [7/8]

◆ RandElement() [8/8]

◆ RandExp() [1/2]

◆ RandExp() [2/2]

◆ RandExtremeValue() [1/2]

◆ RandExtremeValue() [2/2]

◆ RandFill() [1/4]

◆ RandFill() [2/4]

◆ RandFill() [3/4]

◆ RandFill() [4/4]

◆ RandFisherF() [1/2]

◆ RandFisherF() [2/2]

◆ RandGamma() [1/2]

◆ RandGamma() [2/2]

◆ RandGeometric() [1/2]

◆ RandGeometric() [2/2]

◆ RandInt() [1/3]

◆ RandInt() [2/3]

◆ RandInt() [3/3]

◆ RandLogNormal() [1/2]

◆ RandLogNormal() [2/2]

◆ RandNormal() [1/2]

◆ RandNormal() [2/2]

◆ RandPoisson() [1/2]

◆ RandPoisson() [2/2]

◆ RandReal() [1/2]

◆ RandReal() [2/2]

◆ RandSample() [1/7]

◆ RandSample() [2/7]

◆ RandSample() [3/7]

◆ RandSample() [4/7]

◆ RandSample() [5/7]

◆ RandSample() [6/7]

◆ RandSample() [7/7]

◆ RandShuffle()

◆ RandStudentT() [1/2]

◆ RandStudentT() [2/2]

◆ RandVector() [1/6]

◆ RandVector() [2/6]

◆ RandVector() [3/6]

◆ RandVector() [4/6]

◆ RandVector() [5/6]

◆ RandVector() [6/6]

◆ RandWeibull() [1/2]

◆ RandWeibull() [2/2]

变量说明

◆ DefaultSeed