格su（2）规范理论与python中的随机数生成

我目前正在用python编写一个简单的程序来模拟1+1维SU（2）yang mills理论。对于SU（2）的情况，存在一种用于更新链路变量的特定heatbath算法。然而，为了实现该算法，我需要生成一个随机实数X，使得X根据

P（X）=sqrt（1-X^2）*e^（k*X）

分布，其中k是从负无穷大到无穷大的实数

幸运的是，存在一种根据上述分布生成X的算法。利用我有限的python技能，我实现了这样一个算法。这是代码。我这里只使用numpy

def algorithm(k):
    count = 0
    while  1 != 0:
        r1,r2,r3,r4 = np.random.uniform(low=0,high=1),np.random.uniform(low=0,high=1),np.random.uniform(low=0,high=1),np.random.uniform(low=0,high=1)
        L1 = -1/(2*k)*(np.log(r1)+np.log(r3)*np.cos(2*np.pi*r2)**2)
        if r4**2 <= 1 - L1:
            X = 1 -2*L1
            break
        else:
            count = count +  1
            continue
    print(count)
    return X  

def算法（k）：
计数=0
而1！=0:
r1，r2，r3，r4=np.随机.均匀（低=0，高=1），np.随机.均匀（低=0，高=1），np.随机.均匀（低=0，高=1），np.随机.均匀（低=0，高=1）
L1=-1/（2*k）*（np.log（r1）+np.log（r3）*np.cos（2*np.pi*r2）**2）
如果r4**2我不知道是否存在一个内置函数，它会准确返回您想要的分布，但我相信将代码矢量化应该不难。只需使用Warren提到的方法生成
r1
、
r2
、
r3
和
r4
向量，然后执行这些操作。正如DSM所提到的，您也可以使用一个元组作为
size
参数，并通过一个调用完成所有操作

您可以保留循环并以某种方式重复操作，直到获得
N
值，但我只需删除循环并只保留满足条件的数字。这产生的数字少于
N
个，但编码很简单

像这样的东西可能就是你想要的：

def algorithm_2(k, N):
    r1,r2,r3,r4 = np.random.uniform(low=0,high=1, size=(4,N))
    L1 = -1/(2*k)*(np.log(r1)+np.log(r3)*np.cos(2*np.pi*r2)**2)
    reduced_L1 = L1[r4**2 <= 1 - L1]
    return 1-2*reduced_L1

如果你想要一个总是精确返回一个
N
-ary向量的函数，你可以编写一个包装器，继续调用上面的函数，然后连接数组。大概是这样的：

def algorithm_3(k, N):
    total_size =0
    random_arrays = []
    while total_size < N:
        random_array = algorithm_2(k, N)
        total_size += len(random_array)
        random_arrays.append(random_array)
    return np.hstack(random_arrays)[:N]

def算法_3（k，N）：
总尺寸=0
随机_数组=[]
当总尺寸小于N时：
随机数组=算法2（k，N）
总大小+=len（随机数组）
随机数组。追加（随机数组）
返回np.hstack（随机_数组）[:N]
FYI：接受
size
参数。您可以使用
size=4
在一次调用中生成四个值<代码>而1！=0

？你为什么要写这个？只需使用

，而True:

。。。无论如何，您可以尝试对操作进行矢量化，一次最多生成

N

个随机数。。。为

r1

创建带有

N

随机值的向量，与

r2

、

r3

和

r4

相同。然后计算

L1

（这将是

N

元素向量）。然后根据该条件选择

L1

行，并计算

X

，该行将具有

，而这对性能影响不大（坦白说，我可能不会首先分解数组），
np.random.random（（4，N））
比随机行的RHS短得多。@DSM您完全正确。我只是对操作代码做了最少的修改，我想我可以稍微改进一下。
def algorithm_3(k, N):
    total_size =0
    random_arrays = []
    while total_size < N:
        random_array = algorithm_2(k, N)
        total_size += len(random_array)
        random_arrays.append(random_array)
    return np.hstack(random_arrays)[:N]