我有以下功能：

def get_denom(n_comp,qs,x,cp,cs):
'''
len(n_comp) = 1 # number of proteins
len(cp) = n_comp # protein concentration
len(qp) = n_comp # protein capacity
len(x) = 3*n_comp + 1 # fit parameters
len(cs) = 1

'''
    k = x[0:n_comp]
    sigma = x[n_comp:2*n_comp]
    z = x[2*n_comp:3*n_comp]

    a = (sigma + z)*( k*(qs/cs)**(z-1) )*cp
    denom = np.sum(a) + cs
    return denom

subroutine get_denom (qs,x,cp,cs,n_comp,denom)

! Calculates the denominator in the SMA model (Brooks and Cramer 1992)
! The function is called at a specific salt concentration and isotherm point
! I loops over the number of components

implicit none

! declaration of input variables
integer, intent(in) :: n_comp ! number of components
double precision, intent(in) :: cs,qs ! salt concentration, free ligand concentration
double precision, dimension(n_comp), INTENT(IN) ::cp ! protein concentration
double precision, dimension(3*n_comp + 1), INTENT(IN) :: x ! parameters

! declaration of local variables
double precision, dimension(n_comp) :: k,sigma,z
double precision :: a
integer :: i

! declaration of outpur variables
double precision, intent(out) :: denom

k = x(1:n_comp) ! equlibrium constant
sigma = x(n_comp+1:2*n_comp) ! steric hindrance factor
z = x(2*n_comp+1:3*n_comp) ! charge of protein

a = 0.
do i = 1,n_comp
    a = a + (sigma(i) + z(i))*(k(i)*(qs/cs)**(z(i)-1.))*cp(i)
end do

denom = a + cs

end subroutine get_denom

import numpy as np
import get_denom as fort_denom
import get_denom_vec as fort_denom_vec
from matplotlib import pyplot as plt
%matplotlib inline

def get_denom(n_comp,qs,x,cp,cs):
    k = x[0:n_comp]
    sigma = x[n_comp:2*n_comp]
    z = x[2*n_comp:3*n_comp]
    # calculates the denominator in Equ 14a - 14c (Brooks & Cramer 1992)
    a = (sigma + z)*( k*(qs/cs)**(z-1) )*cp
    denom = np.sum(a) + cs
    return denom

n_comp = 100
cp = np.tile(1.243,n_comp)
cs = 100.
qs = np.tile(1100.,n_comp)
x= np.random.rand(3*n_comp+1)
denom = np.empty(1)
%timeit get_denom(n_comp,qs,x,cp,cs)
%timeit fort_denom.get_denom(qs,x,cp,cs,n_comp)
%timeit fort_denom_vec.get_denom(qs,x,cp,cs,n_comp)

import cython
# import both numpy and the Cython declarations for numpy
import numpy as np
cimport numpy as np

@cython.boundscheck(False)
@cython.wraparound(False)
def get_denom(int n_comp,np.ndarray[double, ndim=1, mode='c'] qs, np.ndarray[double, ndim=1, mode='c'] x,np.ndarray[double, ndim=1, mode='c'] cp, double cs):

    cdef int i
    cdef double a
    cdef double denom   
    cdef double[:] k = x[0:n_comp]
    cdef double[:] sigma = x[n_comp:2*n_comp]
    cdef double[:] z = x[2*n_comp:3*n_comp]
    # calculates the denominator in Equ 14a - 14c (Brooks & Cramer 1992)
    a = 0.
    for i in range(n_comp):
    #a += (sigma[i] + z[i])*( pow( k[i]*(qs[i]/cs), (z[i]-1) ) )*cp[i]
        a += (sigma[i] + z[i])*( k[i]*(qs[i]/cs)**(z[i]-1) )*cp[i]

    denom = a + cs

    return denom

def get_denom_numexp(n_comp,qs,x,cp,cs):
    k = x[0:n_comp]
    sigma = x[n_comp:2*n_comp]
    z = x[2*n_comp:3*n_comp]
    # calculates the denominator in Equ 14a - 14c (Brooks & Cramer 1992)
    a = ne.evaluate('(sigma + z)*( k*(qs/cs)**(z-1) )*cp' )
    return cs + np.sum(a)

ne.set_num_threads(1)  # using just 1 thread
%timeit get_denom_numexp(n_comp,qs,x,cp,cs)

最佳答案

用过了。
好的，最后，我们被允许在我们的一个盒子上安装numpy等，这可能是对你原来的文章的一个全面的解释。
简而言之，你最初的问题在某种意义上是“错误的问题”。此外，其中一位撰稿人滥用和误传了许多令人恼火的信息，这些错误和捏造值得注意，以免有人误相信这些错误，并为此付出代价。
另外，我决定将这个答案作为一个单独的答案提交，而不是出于如下所示的原因和适当性编辑我4月14日的答案。
A部分：操作的答案
首先，处理原始帖子中的问题：您可能还记得，我只能对Fortran方面进行WRT评论，因为我们的政策严格要求安装哪些软件以及在我们的机器上安装在哪里，而且我们还没有准备好python等（直到现在）。我也反复说过，你的结果的特点是有趣的，我们可以称之为弯曲的特点，或者说是“凹陷”。
此外，纯粹使用“相对”结果（因为您没有发布绝对计时，而且我当时也没有麻木感），我曾多次指出，其中可能隐藏着一些重要信息。
事实就是这样。
首先，我想确保我可以复制您的结果，因为我们通常不使用python/f2py，所以在您的结果中不明显包含了什么编译器设置等，所以我执行了各种测试，以确保我们在与苹果交谈（我4月14日的回答表明，调试与恢复租赁/O2有很大区别）。
图1显示了我对以下三种情况的python结果：原始的python/numpy内部子程序（称为p，我只是剪切/粘贴原始文件）、原始的基于do的fortran s/r（称为fdo，和以前一样，我只是复制/粘贴原始文件）和其中一种变体i had之前建议依赖数组部分，因此需要sum（）（调用这个fsas，通过编辑原始fdo创建）。图1显示了通过timeit的绝对计时。
图2显示了基于相对策略（除以python/numpy（p）计时）的相对结果。仅显示两个（相对）Fortran变体。
很明显，这些复制了你最初的情节中的角色，我们可能相信我的测试似乎与你的测试一致。
现在，您最初的问题是：“为什么随着数组大小的增加，Fortran的速度越来越接近numpy？”.
事实上，事实并非如此。纯粹是依靠“相对”时间安排的假象/扭曲，可能会给人留下这样的印象。
从图1可以看出，在绝对计时的情况下，numpy和fortran显然在分散。所以，事实上，如果你愿意的话，Fortran的结果是从numpy开始的，反之亦然。
一个更好的问题，也是在我之前的评论中反复出现的一个问题，是为什么这些向上弯曲在第一位（例如c.f.线性）？我以前的fortran-only结果显示了一个“基本上”平坦的相对性能比（4月14日图表/答案中的黄线），因此我推测在python方面发生了一些有趣的事情，并建议进行检查。
有一种方法可以证明这一点，那就是使用一种不同的相对度量。我用它自己的最高值（即n_comp=10 k）来划分每个（绝对）系列，以了解这种“内部相对”性能是如何展开的（那些被称为？？10 k值，表示n_comp=10000）的计时。图3显示了p、fdo和fsas作为p/p10k、fdo/fdo10K和fsas/fsas10K的这些结果。为了清楚起见，y轴具有对数刻度。很明显，随着p结果的n_comp c.f.的降低，Fortran变种的表现相对更好（例如红圈注释部分）。
换言之，Fortran在减小数组大小方面非常（非线性）高效。不清楚为什么python会因为减少n_comp而做得这么糟糕…但它确实存在，而且可能存在内部开销/设置等问题，以及解释程序与编译器之间的差异等。
所以，并不是Fortran“追赶”了Python，相反，它继续与Python保持距离（见图1）。然而，随着n_comp的减少，python和fortran之间的非线性差异产生了明显反直觉和非线性的“相对”计时。
因此，随着n_comp的增加和每个方法“稳定”到一个或多或少的线性模式，曲线变平，以表明它们的差异是线性增长的，并且相对比率固定到一个近似常数（忽略内存争用、SMP问题等）。这很容易看出n_comp是否允许大于10000，但4月14日我的答案中的黄线已经显示了这一点，仅针对Fortran的S/R。
旁白：我的偏好是创建自己的定时例程/函数。时间似乎很方便，但在那个“黑匣子”里面有很多事情。设置自己的循环和结构，确定定时功能的属性/分辨率对于正确评估很重要。

关于python - 性能比较Fortran，Numpy，Cython和Numexpr，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28387340/