小编kon*_*ant的帖子

我有一个像图中所示的三角形镶嵌.

给定N曲面细分中的三角形数量,我有一个N X 3 X 3数组存储(x, y, z)每个三角形的所有三个顶点的坐标.我的目标是为每个三角形找到共享相同边缘的相邻三角形.这是一个错综复杂的部分是我不重复邻居计数的整个设置.也就是说,如果三角形j已被计为三角形的邻居i,则三角形i不应再次计为三角形的邻居j.这样,我想有一个地图存储每个索引三角形的邻居列表.如果我从索引中的三角形开始i,那么索引i将有三个邻居,而所有其他的将有两个或更少.举个例子,假设我有一个存储三角形顶点的数组:

import numpy as np
vertices = np.array([[[2.0, 1.0, 3.0],[3.0, 1.0, 2.0],[1.2, 2.5, -2.0]],
                     [[3.0, 1.0, 2.0],[1.0, 2.0, 3.0],[1.2, -2.5, -2.0]],
                     [[1.0, 2.0, 3.0],[2.0, 1.0, 3.0],[3.0, 1.0, 2.0]],
                     [[1.0, 2.0, 3.0],[2.0, 1.0, 3.0],[2.2, 2.0, 1.0]],
                     [[1.0, 2.0, 3.0],[2.2, 2.0, 1.0],[4.0, 1.0, 0.0]],
                     [[2.0, 1.0, 3.0],[2.2, 2.0, 1.0],[-4.0, 1.0, 0.0]]])

假设我从顶点索引开始计数2,即具有顶点的那个[[1.0, 2.0, 3.0],[2.0, …

我有一个一维的numpy数组,它的大小非常大.对于数组的每个条目,我需要生成一个线性间隔的子数组,直到该条目值.以下是我的例子.

import numpy as np
a = np.array([2, 3])
b = np.array([np.linspace(0, i, 4) for i in a])

在这种情况下,存在大小为4的线性空间.上面代码中的最后一个语句涉及一个for loop如果a非常大则相当慢.有没有一个技巧来实现这一点numpy？

我很难理解指令的具体js作用jb。我知道jb如果低于则跳转。jb但是，和 之间有什么区别jle。同样，js在我看来，它相当于jb，因为它意味着如果签名则跳转。任何帮助，将不胜感激。

在我的python代码中，我需要循环大约 2500 万次，我希望尽可能对其进行优化。循环内的操作非常简单。为了使代码高效，我使用了numba模块，这有很大帮助，但如果可能的话我想进一步优化代码。

这是一个完整的工作示例：

import numba as nb
import numpy as np
import time 
#######create some synthetic data for illustration purpose##################
size=5000
eps = 0.2
theta_c = 0.4
temp = np.ones(size)
neighbour = np.random.randint(size, size=(size, 3)) 
coschi = np.random.random_sample((size))
theta = np.random.random_sample((size))*np.pi/2
pwr = np.cos(theta)
###################end of dummy data##########################

###################-----main loop------###############
@nb.jit(fastmath=True)
def func(theta, pwr, neighbour, coschi, temp):
    for k in range(np.argmax(pwr), 5000*(pwr.size)): 
        n = k%pwr.size
        if (np.abs(theta[n]-np.pi/2.)<np.abs(theta_c)):
                adj = neighbour[n,1]
        else:
                adj = neighbour[n,0]
        psi_diff …

假设我有一个非常大的numpy数组a,我想将数值1添加到数组的每个元素.从我到目前为止所读到的:

a += 1 

这是一个很好的方式,而不是:

a = a + 1

因为在第二种情况下a,在不同的存储器槽中创建新阵列,而在第一种情况下,旧阵列在相同的存储器槽中被有效地替换.

假设我想要执行以下操作:

a = 1-a

做上述内存有效的方法是什么？

我正在查看scipy.ndimage.gaussian_filter，但无法理解sigma这里的含义。sigma= n平均值是n像素数，因此n点所有边上像素数内的区域对平均贡献最大？

我有一段代码,它基本上评估了一些数值表达式,并使用它来集成某些范围的值.当前的一段代码在大约内部运行8.6 s,但我只是使用模拟值,而我的实际数组要大得多.特别是,我的实际大小freq_c= (3800, 101)和大小number_bin = (3800, 100),使得下面的代码真的效率低下,因为实际数组的总执行时间将接近9分钟.代码的一部分是非常缓慢的评估k_one_third和k_two_third我已经使用numexpr.evaluate("..")过的代码,它将代码加速了大约10-20%.但是,我已经避免numexpr在下面,所以任何人都可以运行它而无需安装包.还有其他方法可以提高此代码的速度吗？一些因素的改进也足够好.请注意for loop,由于内存问题,几乎不可避免,因为数组非常大,我通过循环一次操作每个轴.我也想知道numba jit这里是否可以进行优化.

import numpy as np
import scipy 
from scipy.integrate import simps as simps
import time

def k_one_third(x):
    return (2.*np.exp(-x**2)/x**(1/3) + 4./x**(1/6)*np.exp(-x)/(1+x**(1/3)))**2

def k_two_third(x):
    return (np.exp(-x**2)/x**(2/3) + 2.*x**(5/2)*np.exp(-x)/(6.+x**3))**2

def spectrum(freq_c, number_bin, frequency, gamma, theta):
    theta_gamma_factor = np.einsum('i,j->ij', theta**2, gamma**2)
    theta_gamma_factor += 1.
    t_g_bessel_factor = 1.-1./theta_gamma_factor
    number = np.concatenate((number_bin, np.zeros((number_bin.shape[0], 1), dtype=number_bin.dtype)), axis=1)
    number_theta_gamma = np.einsum('jk, …