Python：如何避免构建这个矩阵的循环，并更快地计算它的行列式？

Question

我在用Python构建矩阵时遇到了一些问题。 每个元素都有一个循环，each element A_{ij}是图片中的形式，这里X是Q元素的数组（在下面的代码中用席表示）。在

我试过下面的代码，但时间太长了。我想这是因为循环的数量，所以我想把它看作两个矩阵的乘积，但是由于lambda有两个维度，所以它不起作用。在

既然这些代码将作为一个函数出现并将被多次使用，有没有什么方法可以使它运行得更快？非常感谢你！！在

def lambdak(i,j,alpha,rho):
    return math.pi * alpha**2 * rho * math.exp(-math.pi**2 * alpha**2 *(i**2 + j**2))
def phik(i,j,x,alpha,rho):
    return cmath.exp(2 * math.pi * 1j * (i*x[0] + j*x[1]))
alpha = 0.5
rho = 50
num = 30
x = np.random.uniform(-0.5,0.5,num)
y = np.random.uniform(-0.5,0.5,num)
xi = np.zeros((num,3))
for i in range(num):
    xi[i] = np.array([x[i], y[i], 0])
q = len(xi)
A = [[np.sum(list(map(lambda j:
                     np.sum(list(map(lambda i:
                                    lambdak(i,j,alpha,rho)/(1-lambdak(i,j,alpha,rho))* phik(i,j,xi[x]-xi[y],alpha,rho),
                                    range(-N,N+1)))),
                     range(-N,N+1)))) for x in range(q)] for y in range(q)]
a = np.linalg.inv(A)

Answer 1

正如您所怀疑的，性能不佳的原因是您的循环。我假设您正在使用numpy，因为您在循环中调用了np.sum。诀窍是将循环从内到外，然后将更大的结构（即矩阵）传递给numpy函数。在

这样做，可以显著提高性能。上述代码可修改为：

import numpy as np

def lambdak(i,j,alpha,rho):
    return np.pi * alpha**2 * rho * np.exp(-math.pi**2 * alpha**2 *(i**2 + j**2))

def phik(i,j,x,alpha,rho):
    return np.exp(2 * np.pi * 1j * (i*x[:, :, 0] + j*x[:, :, 1]))

alpha = 0.5
rho = 50
num = 30
x = np.random.uniform(-0.5,0.5,num)
y = np.random.uniform(-0.5,0.5,num)
xi = np.zeros((num,3))
for i in range(num):
    xi[i] = np.array([x[i], y[i], 0])

X = np.arange(num).reshape(1,num)
Y = np.arange(num).reshape(num,1)

xi_diff = xi[X] - xi[Y]

N = 30

A = np.sum(map(lambda j:
                np.sum(map(lambda i:
                        lambdak(i,j,alpha,rho)/(1-lambdak(i,j,alpha,rho))* phik(i,j,xi_diff,alpha,rho),
                        range(-N,N+1)), 0),
                     range(-N,N+1)), 0)

a = np.linalg.inv(A)

在这里，外部循环被转换成一个矩阵，它作为一个整体传递给numpy函数。此外，我预先计算XIODIFO，因为整个结构在每个调用中传递（即使只有一部分被^ {CD5> }使用）。在

这给了一个戏剧性的加速。然而，计算中的数值稳定性可能会受到影响，当我比较两种方法的输出时，它们相差大约0.1%。不过，希望这没问题。在