为什么 SymPy 的积分函数在进行定积分时比近似值慢得多？

Question

考虑一下 f = lambda x : 1/x 我想得到它在 2 和 7 之间的定积分。

第一种方法是使用 linspace 并计算超过 10^4 项的黎曼和。

l = list(np.linspace(2,7,10**4))

s = 0

for i in l:
    s+=f(i)*(l[1]-l[0])

第二种方法是使用 SymPy 的集成函数并对其进行评估。

x = sp.symbols('x')
t = sp.integrate(f(x),(x,2,7)).evalf()

输出给我们：

Riemann Sum : 1.2529237036377492
--- 13.025045394897461 milliseconds ---


SymPy : 1.25276296849537
--- 71.07734680175781 milliseconds ---


Delta : 0.0128304512843464 %

我的问题是：对于 delta <.1%，为什么 sympyaround 比黎曼和慢 4 到 5 倍，有什么方法可以改进这两种方法吗？

Answer 1

sympy 是一个 symbolic/algebraic 包，处理复杂的“symbol/expression”对象。

在 isympy 会话中：

In [7]: f = lambda x : 1/x

In [8]: integrate(f(x),(x,2,7)).evalf()
Out[8]: 1.25276296849537

In [9]: integrate(f(x),(x,2,7))
Out[9]: -log(2) + log(7)

In [10]: timeit integrate(f(x),(x,2,7))
10.6 ms ± 26.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [11]: timeit integrate(f(x),(x,2,7)).evalf()
10.8 ms ± 13.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

大部分时间花在符号部分，最后的数值评估相对较快。

您的迭代数值解：

In [45]: f = lambda x : 1/x
In [46]: %%timeit
    ...: s = 0
    ...: for i in l:
    ...:     s+=f(i)*(l[1]-l[0])
    ...: 
5.91 ms ± 157 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

但是使用 numpy 我们可以更快地做到这一点：

In [47]: (f(np.array(l))*(l[1]-l[0])).sum()
Out[47]: 1.2529237036377558
In [48]: timeit (f(np.array(l))*(l[1]-l[0])).sum()
631 µs ± 275 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)

如果输入已经是一个数组就更好了（你的 linspace 没有 `tolist()）：

In [49]: %%timeit larr=np.array(l)
    ...: (f(larr)*(l[1]-l[0])).sum()
61.2 µs ± 735 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

scipy有一堆集成函数，其中大部分使用像QUADPACK这样的编译库。一个基本的是 quad:

In [50]: from scipy.integrate import quad
In [52]: quad(f,2,7)
Out[52]: (1.2527629684953678, 3.2979213205748694e-12)
In [53]: timeit quad(f,2,7)
7.22 µs ± 57.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

根据 full_output 显示 quad 只需调用 f() 21 次，而不是您的迭代调用 10**4 次。

为什么 SymPy 的积分函数在进行定积分时比近似值慢得多？

Why is SymPy's integrate function much slower when doing a definite integral than an approximation?

python

numpy

sympy