RandString / RandUUID 更多...

字符串与 ID 的协作图:

命名空间
namespace	RandX::detail

函数
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
	编译期洗牌数组版本（返回打乱后的副本）

详细描述

RandString / RandUUID

函数说明

◆ MakeStreamEngine()

template<class Engine>
requires detail::StreamEngine<Engine>

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

inlinenodiscardconstexpr

从同一种子创建第 streamId 个不重叠子序列的引擎

参数

streamId	流编号（每个流之间间隔 2^128 步或 2^64 步）
seed	共享种子（默认 DefaultSeed）

返回: 第 streamId 个不重叠子序列的引擎实例

注解: Xoroshiro64 系列无 jump 函数，不支持多流

◆ RandBeta() [1/2]

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

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<std::floating_point T = double>

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<std::integral T = int, class Engine>

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<std::integral T = int>

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

inlinenodiscard

生成二项分布随机数

参数

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

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

函数调用图:

◆ RandBits()

template<int N, std::integral T = std::uint64_t>
requires (N > 0 && N <= 64 && N <= std::numeric_limits<T>::digits)

T RandX::RandBits ( )

inlinenodiscardnoexcept

生成 N 位随机整数

模板参数

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

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

函数调用图:

◆ RandCauchy() [1/2]

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

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<std::floating_point T = double>

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

inlinenodiscard

生成柯西分布随机数

参数

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

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

◆ RandChiSquared() [1/2]

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

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

inlinenodiscard

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

参数

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

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

◆ RandChiSquared() [2/2]

template<std::floating_point T = double>

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

inlinenodiscard

生成卡方分布随机数

参数

n 自由度（默认 1）

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

◆ RandExp() [1/2]

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

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

inlinenodiscard

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

参数

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

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

◆ RandExp() [2/2]

template<std::floating_point T = double>

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

inlinenodiscard

生成指数分布随机数

参数

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

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

◆ RandExtremeValue() [1/2]

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

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<std::floating_point T = double>

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

inlinenodiscard

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

参数

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

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

◆ RandFisherF() [1/2]

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

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<std::floating_point T = double>

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, std::floating_point T = double>

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<std::floating_point T = double>

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

inlinenodiscard

生成伽马分布随机数

参数

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

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

◆ RandGeometric() [1/2]

template<std::integral T = int>

T RandX::RandGeometric ( double p = 0.5 )

inlinenodiscard

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

参数

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

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

函数调用图:

◆ RandGeometric() [2/2]

template<std::integral T = int, class Engine>

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

inlinenodiscard

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

参数

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

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

◆ RandIntCE() [1/2]

template<std::integral T = int, std::uint64_t Seed = DefaultSeed>

T RandX::RandIntCE ( T max )

inlinenodiscardconstexpr

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

参数

max 上界（含）

返回: 使用固定种子在编译期确定的随机整数

函数调用图:

◆ RandIntCE() [2/2]

template<std::integral T = int, std::uint64_t Seed = DefaultSeed>

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

inlinenodiscardconstexpr

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

参数

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

返回: 使用固定种子在编译期确定的随机整数（Lemire 有界法，无模偏差）

函数调用图:

◆ RandLogNormal() [1/2]

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

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<std::floating_point T = double>

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

inlinenodiscard

生成对数正态分布随机数

参数

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

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

◆ RandPoisson() [1/2]

template<std::integral T = int>

T RandX::RandPoisson ( double mean = 1.0 )

inlinenodiscard

生成泊松分布随机数

参数

mean	均值参数（默认 1.0）

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

函数调用图:

◆ RandPoisson() [2/2]

template<class Engine, std::integral T = int>

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

inlinenodiscard

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

参数

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

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

◆ RandString() [1/3]

template<class Engine>

std::string RandX::RandString	(	Engine &	engine,
		std::size_t	n,
		CharSet	cs )

inlinenodiscard

从预设字符集生成随机字符串（指定引擎重载）

参数

engine	自定义随机数引擎
n	字符串长度
cs	预设字符集枚举

返回: 从预设字符集中均匀选取字符组成的随机字符串

函数调用图:

◆ RandString() [2/3]

std::string RandX::RandString	(	std::size_t	length,
		std::string_view	charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" )

inlinenodiscard

生成指定长度的随机字符串

参数

length	字符串长度
charset	可用字符集（默认为字母+数字）

返回: 从 charset 中均匀选取字符组成的随机字符串

异常

std::invalid_argument charset 为空时抛出

函数调用图:

◆ RandString() [3/3]

std::string RandX::RandString	(	std::size_t	n,
		CharSet	cs )

inlinenodiscard

从预设字符集生成随机字符串

参数

n	字符串长度
cs	预设字符集枚举

返回: 从预设字符集中均匀选取字符组成的随机字符串

函数调用图:

◆ RandStudentT() [1/2]

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

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

inlinenodiscard

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

参数

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

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

◆ RandStudentT() [2/2]

template<std::floating_point T = double>

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

inlinenodiscard

生成学生 t 分布随机数

参数

n 自由度（默认 1）

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

◆ RandUUID() [1/2]

std::string RandX::RandUUID ( )

inlinenodiscard

函数调用图:

◆ RandUUID() [2/2]

template<class Engine>

std::string RandX::RandUUID ( Engine & engine )

inlinenodiscard

生成随机 UUID v4 字符串

返回: 格式为 xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx 的 UUID 字符串

警告: 使用默认 PRNG（非 CSPRNG），不适用于安全敏感标识符；安全场景请改用 ChaCha20 引擎重载或 SecureRandomBytes

函数调用图:

◆ RandWeibull() [1/2]

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

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<std::floating_point T = double>

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

inlinenodiscard

生成韦布尔分布随机数

参数

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

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

◆ ShuffleCE()

template<std::random_access_iterator It, std::uint64_t Seed = DefaultSeed>

void RandX::ShuffleCE	(	It	first,
		It	last )

constexprnoexcept

编译期 Fisher-Yates 洗牌

模板参数

It	随机访问迭代器类型
Seed	编译期随机种子（默认 DefaultSeed；如需不同洗牌结果可传入自定义 Seed 模板参数）

参数

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

注解: 内部统一使用 Xoshiro256StarStar 在 constexpr 上下文中生成随机排列

函数调用图:

◆ ShuffledArray()

template<class T, std::size_t N, std::uint64_t Seed = DefaultSeed>

std::array< T, N > RandX::ShuffledArray ( std::array< T, N > arr )

nodiscardconstexprnoexcept

编译期洗牌数组版本（返回打乱后的副本）

模板参数

T	数组元素类型
N	数组长度
Seed	编译期随机种子（默认 DefaultSeed）

参数

arr 待打乱的数组

返回: 打乱后的数组副本

函数调用图:

命名空间

函数

详细描述

函数说明

◆ MakeStreamEngine()

◆ RandBeta() [1/2]

◆ RandBeta() [2/2]

◆ RandBinomial() [1/2]

◆ RandBinomial() [2/2]

◆ RandBits()

◆ RandCauchy() [1/2]

◆ RandCauchy() [2/2]

◆ RandChiSquared() [1/2]

◆ RandChiSquared() [2/2]

◆ RandExp() [1/2]

◆ RandExp() [2/2]

◆ RandExtremeValue() [1/2]

◆ RandExtremeValue() [2/2]

◆ RandFisherF() [1/2]

◆ RandFisherF() [2/2]

◆ RandGamma() [1/2]

◆ RandGamma() [2/2]

◆ RandGeometric() [1/2]

◆ RandGeometric() [2/2]

◆ RandIntCE() [1/2]

◆ RandIntCE() [2/2]

◆ RandLogNormal() [1/2]

◆ RandLogNormal() [2/2]

◆ RandPoisson() [1/2]

◆ RandPoisson() [2/2]

◆ RandString() [1/3]

◆ RandString() [2/3]

◆ RandString() [3/3]

◆ RandStudentT() [1/2]

◆ RandStudentT() [2/2]

◆ RandUUID() [1/2]

◆ RandUUID() [2/2]

◆ RandWeibull() [1/2]

◆ RandWeibull() [2/2]

◆ ShuffleCE()

◆ ShuffledArray()