如何用Python生成4个范围-1.0至1.0且和为1的随机数？

你的递归拒绝采样方法虽然可行，但确实存在效率不稳定的问题（平均约2.1次尝试才能得到一个有效样本）。下面提供两种更高效的实现方式：

方案一：批量拒绝采样（简单高效，易实现） #

利用numpy的向量化操作批量生成样本，一次性筛选出符合条件的结果，避免单样本递归的开销，效率比原方法提升显著。

import numpy as np

def generate_random_numbers_batch(n_samples=1):
    # 批量生成3列随机数，每一行对应一组候选的前3个数
    candidates = np.random.uniform(-1.0, 1.0, (n_samples * 2, 3))
    sums = np.sum(candidates, axis=1)
    # 筛选出前3个数的和在[0,2]的样本（保证第4个数在[-1,1]）
    valid_mask = (sums >= 0) & (sums <= 2)
    valid_candidates = candidates[valid_mask]
    valid_sums = sums[valid_mask]
    
    # 计算第4个数
    fourth_numbers = 1 - valid_sums
    result = np.column_stack((valid_candidates, fourth_numbers))
    
    # 如果生成的有效样本不足，递归补充（这里乘以2是为了减少递归次数）
    if len(result) < n_samples:
        remaining = n_samples - len(result)
        additional = generate_random_numbers_batch(remaining)
        result = np.vstack((result, additional))
    
    return result[:n_samples]

优点：代码简单，利用numpy向量化操作大幅提升效率，生成的样本是可行域上的均匀分布。
缺点：仍存在少量拒绝，但批量生成后拒绝的概率被摊薄，实际效率很高。

方案二：无拒绝直接生成（效率最高，分布严格均匀） #

通过变量转换，将问题转化为生成满足特定和的均匀分布变量，完全避免拒绝采样，适合需要大量样本的场景。

import numpy as np

def generate_T(n_samples):
    # 生成均匀分布的变量，对应T∈[1.5,2.5]的概率区间
    u = np.random.uniform(0, 23/48, n_samples)
    t = np.empty(n_samples)
    
    # 处理T∈[1.5,2]的情况，用牛顿迭代解三次方程
    mask_low = u <= 16/48
    u_low = u[mask_low]
    t_low = np.full_like(u_low, 1.75)  # 初始值设为区间中点
    for _ in range(5):  # 迭代5次足够收敛
        f = 2 * t_low**3 - 9 * t_low**2 + 9 * t_low + 6 * u_low
        f_prime = 6 * t_low**2 - 18 * t_low + 9
        t_low -= f / f_prime
    t[mask_low] = t_low
    
    # 处理T∈[2,2.5]的情况，直接求解
    mask_high = ~mask_low
    u_high = u[mask_high]
    t_high = 3 - np.cbrt(3 - 6 * u_high)
    t[mask_high] = t_high
    
    return t

def decompose_T(t):
    # 将T分解为三个[0,1]区间的数之和
    n_samples = len(t)
    u = np.empty((n_samples, 3))
    
    # 处理T∈[1.5,2]
    mask_low = t <= 2
    t_low = t[mask_low]
    s_low = t_low - 1
    u1 = np.random.uniform(0, s_low)
    u2 = s_low - u1
    u[mask_low] = np.column_stack((1, u1, u2))
    
    # 处理T∈[2,2.5]
    mask_high = ~mask_low
    t_high = t[mask_high]
    s_high = 3 - t_high
    u1 = np.random.uniform(0, s_high)
    u2 = s_high - u1
    u[mask_high] = np.column_stack((1 - u1, 1 - u2, 1))
    
    return u

def generate_random_numbers_direct(n_samples=1):
    t = generate_T(n_samples)
    u = decompose_T(t)
    # 转换为[-1,1]区间的数
    x = 2 * u - 1
    # 计算第4个数
    x4 = 1 - np.sum(x, axis=1)
    result = np.column_stack((x, x4))
    
    # 验证（可选）
    assert np.all((result >= -1) & (result <= 1))
    assert np.allclose(np.sum(result, axis=1), 1)
    
    return result

优点：完全无拒绝采样，效率最高，生成的样本严格服从可行域上的均匀分布。
缺点：代码稍复杂，涉及数值迭代求解。

内容的提问来源于stack exchange，提问作者CS1999