Question

我试图通过将一堆嵌套循环移植到fortran并将它们作为子例程调用来加快python代码的速度。

但是我的很多循环都调用numpy，还有来自scipy的特殊功能，例如贝塞尔函数。

在我尝试使用fortran之前，我想知道是否可以将scipy和numpy导入我的fortran子例程并调用bessel函数的模块吗？

否则我必须在fortran中创建bessel函数才能使用它吗？

理想情况下，我将创建某种子例程来优化下面的代码。这只是我整个项目的一小段，旨在让您大致了解我要完成的工作。

我知道我还应该采取其他措施来提高速度，但是现在我正在研究在我的主要python程序中调用fortran子例程的好处。

    for m in range(self.MaxNum_Eigen):
        #looping throught the eigenvalues for the given maximum number of eigenvalues allotted
        bm = self.beta[m]


        #not sure
        #*note: rprime = r. BUT tprime ~= t.

        #K is a list of 31 elements for this particular case

        K = (bm / math.sqrt( (self.H2**2) + (bm**2) ))*(math.sqrt(2) / self.b)*((scipy.special.jv(0, bm * self.r))/ (scipy.special.jv(0, bm * self.b))) # Kernel, K0(bm, r).

        #initial condition
        F = [37] * (self.n1)

        # Integral transform of the initial condition
        #Fbar = (np.trapz(self.r,self.r*K*F))

        '''
            matlab syntax trapz(X,Y), x ethier spacing or vector
            matlab:     trapz(r,r.*K.*F)                trapz(X,Y)
            python:     np.trapz(self.r*K*F, self.r)    trapz(Y,X)

        '''

        #*(np.trapz(self.r,self.r*K*F))
        Fbar = np.ones((self.n1,self.n2))*(np.trapz(self.r*K*F, self.r))

        #steady state condition: integral is in steady state
        SS = np.zeros((sz[0],sz[1]))

        coeff = 5000000*math.exp(-(10**3)) #defining value outside of loop with higher precision

        for i in range(sz[0]):
            for j in range(sz[1]):

                '''
                    matlab reshape(Array, size1, size2) takes multiple arguments the item its resizeing and the new desired shape

                    create self variables and so we are not re-initializing them over and over agaian?

                    using generators? How to use generators

                '''
                s = np.reshape(tau[i,j,:],(1,n3))


                # will be used for rprime and tprime in Ozisik solution.
                [RR,TT] = np.meshgrid(self.r,s)



                '''
                    ##### ERROR DUE TO ROUNDING OF HEAT SOURCE ####

                    error in rounding  5000000*math.exp(-(10**3)) becomes zero

                    #log10(e−10000)=−10000∗(0.4342944819)=−4342.944819

                    #e−1000=10−4342.944819=10−4343100.05518=1.13548386531×10−4343

                '''

                #g = 5000000*math.exp(-(10**3)) #*(RR - self.c*TT)**2) #[W / m^2] heat source.
                g = coeff * (RR - self.c*TT)**2


                K = (bm/math.sqrt(self.H2**2 + bm**2))*(math.sqrt(2)/self.b)*((scipy.special.jv(0,bm*RR))/(scipy.special.jv(0,bm*self.b)))

                #integral transform of heat source
                gbar = np.trapz(RR*K*g, self.r, 2) #trapz(Y,X,dx (spacing) )
                gbar = gbar.transpose()



                #boundary condition. BE SURE TO WRITE IN TERMS OF s!!!
                f2 = self.h2 * 37

                A = (self.alpha/self.k)*gbar + ((self.alpha*self.b)/self.k2)*((bm/math.sqrt(self.H2**2 + bm**2))*(math.sqrt(2)/self.b)*((scipy.special.jv(0,bm*self.b))/(scipy.special.jv(0,bm*self.b))))*f2
                #A is essentially a constant is this correct all the time?
                #What does A represent

                SS[i, j] = np.trapz(np.exp( (-self.alpha*bm**2)*(T[i,j] - s) )*A, s)

        #INSIDE M loop
        K = (bm / math.sqrt((self.H2 ** 2) + (bm ** 2)))*(math.sqrt(2) /self.b)*((scipy.special.jv(0, bm * R))/ (scipy.special.jv(0, bm * self.b)))


        U[:,:, m] = np.exp(-self.alpha * bm ** 2 * T)* K* Fbar + K* SS

        #print(['Eigenvalue ' num2str(m) ', found at time ' num2str(toc) ' seconds'])

Answer 1

评论中给出的答案的汇编

针对我的代码的答案：正如涡旋所提到的那样，我的代码本身并未完全使用numpy和scipy包。

关于Bessel，函数“ royvib”提到使用scipy中的.jo而不是.jv。调用特殊的Bessel函数jv。这在计算上要昂贵得多，尤其是因为我知道我将对许多声明使用零阶贝塞尔函数，所以从jv-> j0的微小更改解决了该问题。

此外，我在循环外声明了变量，以防止昂贵的调用来搜索我的适当函数。下面的示例。

之前

for i in range(SomeLength):
    some_var = scipy.special.jv(1,coeff)

之后

Bessel = scipy.special.jv
for i in range(SomeLength):
    some_var = Bessel(1,coeff)

通过不使用点（'。'）命令在每个循环中浏览库来存储函数节省的时间。但是请记住，这确实使python的可读性降低，这是我选择在python中进行此项目的主要原因。我没有确切的时间来完成此步骤。

Fortran特定：由于我能够改进自己的python代码，因此我没有走这条路，因为它没有细节问题，但是“高性能标记”指出的一般答案是，是的，已经有一些库可以处理Fortran中的Bessel函数。 / p>

如果我将代码移植到Fortran或使用f2py混合Fortran和python，我将相应地更新此答案。

我可以在fortran中使用numpy和scipy之类的库吗？

1 个答案: