防止SymPy中的指数求值

Question

我正在使用SymPy作为包含许多指数函数的代码生成器。因此，对于数值稳定性而言重要的是，不评估指数的参数。我想防止这种情况：

>>> import sympy as sp
>>> x, y = sp.symbols('x y')
>>> expr = sp.exp(5.*x - 10.)
>>> print(expr)
4.53999297624849e-5*exp(5.0*x)

因为它可能导致数字上不正确的结果。

我可以防止指数的评估，如下所示：

>>> expr = sp.exp(5.*x - 10., evaluate=False)
>>> print(expr)
exp(5.0*x - 10.0)

但是，当我在表达式上执行诸如替换或微分之类的操作时，将再次计算指数：

>>> expr = sp.exp(5.*x - 10., evaluate=False)
>>> expr.subs(x, y)
4.53999297624849e-5*exp(5.0*y)
>>> expr.diff(x, 1)
5.0*(4.53999297624849e-5*exp(5.0*x))

SymPy中防止在此类操作下进行指数求值的正确方法是什么？

Answer 1

最明显的一点是，您将float用于整数值，例如：

In [8]: exp(5*x - 10)                                                                                                             
Out[8]: 
 5⋅x - 10
ℯ        

In [9]: exp(5.*x - 10.)                                                                                                           
Out[9]: 
                     5.0⋅x
4.53999297624849e-5⋅ℯ

[也许在您的实际问题中，您想与非整数合作。同样，应该使用理性进行精确计算：

In [10]: exp(Rational(1, 3)*x - S(3)/2)                                                                                           
Out[10]: 
 x   3
 ─ - ─
 3   2
ℯ 

也许您的输入数字不是很合理，并且在Python浮动时可以使用它们，但是您希望避免对其求值。您可以使用符号，然后仅在评估时替换它们：

In [13]: exp(a*x + b).evalf(subs={a:5.0, b:10.})                                                                                  
Out[13]: 
 a⋅x + b
ℯ       

In [14]: exp(a*x + b).evalf(subs={x:1, a:5.0, b:10.})                                                                             
Out[14]: 3269017.37247211

In [15]: exp(a*x + b).subs({a:5.0, b:10.})                                                                                        
Out[15]: 
                  5.0⋅x
22026.4657948067⋅ℯ  

如果所有这些都看起来很尴尬，而您确实只是想塞进浮子并阻止评估，则可以使用UnevaluatedExpr：

In [21]: e = exp(UnevaluatedExpr(5.0)*x - UnevaluatedExpr(10.))                                                                   

In [22]: e                                                                                                                        
Out[22]: 
 x⋅5.0 - 10.0
ℯ            

In [23]: e.doit()    # doit triggers evaluation                                                                                                             
Out[23]: 
                     5.0⋅x
4.53999297624849e-5⋅ℯ