使用（numpy）浮动时Sympy的结果不正确

时间：2015-06-26 10:31:28

标签： python sympy

我正在尝试从时间相关的旋转矩阵RE(t)计算velocity tensor（即纬度为48.3°的地球自转）。这是通过确定偏斜对称矩阵SE(t) = dRE(t)/dt * RE.T来实现的。使用float而不是Sympy表达式时，我得到的结果不正确，如下例所示：

from IPython.display import display
import sympy as sy

sy.init_printing()  # LaTeX like pretty printing for IPython


def mk_rotmatrix(alpha, coord_ax="x"):
    """ Rotation matrix around coordinate axis """
    ca, sa = sy.cos(alpha), sy.sin(alpha)
    if coord_ax == "x":
        return sy.Matrix([[1,  0,   0],
                          [0, ca, -sa],
                          [0, sa, +ca]])
    elif coord_ax == 'y':
        return sy.Matrix([[+ca, 0, sa],
                          [0,   1,  0],
                          [-sa, 0, ca]])
    elif coord_ax == 'z':
        return sy.Matrix([[ca, -sa, 0],
                          [sa, +ca, 0],
                          [0,    0, 1]])
    else:
        raise ValueError("Parameter coord_ax='" + coord_ax +
                         "' is not in ['x', 'y', 'z']!")


t, lat = sy.symbols("t, lat", real=True)  # time and latitude
omE = 7.292115e-5  # rad/s -- earth rotation rate (15.04107 °/h)
lat_sy = 48.232*sy.pi/180  # latitude in rad
lat_fl = float(lat_sy)  # latitude as float
print("\nlat_sy - lat_fl = {}".format((lat_sy - lat_fl).evalf()))

# earth rotation matrix at latitiude 48.232°:
RE = (mk_rotmatrix(omE*t, "z") * mk_rotmatrix(lat - sy.pi/2, "y"))
# substitute latitude with sympy and float value:
RE_sy, RE_fl = RE.subs(lat, lat_sy), RE.subs(lat, lat_fl)

# Angular velocity in world coordinates as skew symmetric matrix:
SE_sy = sy.simplify(RE_sy.diff(t) * RE_sy.T)
SE_fl = sy.simplify(RE_fl.diff(t) * RE_fl.T)

print("\nAngular velocity with Sympy latitude ({}):".format(lat_sy))
display(SE_sy)  # correct result
print("\nAngular velocity with float latitude ({}):".format(lat_fl))
display(SE_fl)  # incorrect result

结果是：

calculation results

对于浮动纬度，尽管只有-3e-17与Sympy值不同，但结果完全错误。我不清楚为什么会这样。从数字上看，这种计算似乎没有问题。

我的问题是，如何解决这些问题。我应该避免混合Sympy和float / Numpy数据类型吗？对于更复杂的设置，很难检测到它们。

PS：Sympy版本是0.7.6。

2 个答案:

答案 0 :(得分：3)

我认为这可能是Sympy的一个错误;当我在我的系统上运行你的脚本（Ubuntu 14.04 64位，Python 2.7，Sympy 0.7.4.1）时，我得到了

lat_sy - lat_fl = -2.61291277482447e-17

Angular velocity with Sympy latitude (0.267955555555556*pi):
Matrix([
[          0, -7.292115e-5, 0],
[7.292115e-5,            0, 0],
[          0,            0, 0]])

Angular velocity with float latitude (0.841807204822):
Matrix([
[3.3881317890172e-21*sin(0.0001458423*t),                     -7.29211495242194e-5, 0],
[                    7.29211495242194e-5, -3.3881317890172e-21*sin(0.0001458423*t), 0],
[                                      0,                                        0, 0]])

看起来不错。

我不确定该建议：您可以尝试使用Sympy的旧版本而不是0.7.6，或者来自Github的最新版本。

[回答评论]至于为什么对角线不为零，我的第一个评论是3e-21 / 7e-5约为4e-17; IEEE754 64位（“浮动”） 数值精度约为2e-16。在3e-21rad / s时，一次旋转需要60万亿年（约2e21秒）。别担心。

我不完全确定这里发生了什么，但是在将其添加到您的脚本之后

def matrix_product_element(a, b, i, j):
    v = a[3*i:3*i+3]
    w = b[j::3]
    summand_list = [v[k]*w[k]
                    for k in range(3)]

    print('element ({},{})'.format(i, j))
    print('  summand_list: {}'.format(summand_list))
    print('  sum(summand_list): {}'.format(sum(summand_list)))
    print('  sum(summand_list).simplify(): {}'.format(sum(summand_list)))

matrix_product_element(RE_fl.diff(t), RE_fl.T, 0, 0)
matrix_product_element(RE_fl.diff(t), RE_fl.T, 1, 0)
matrix_product_element(RE_fl.diff(t), RE_fl.T, 2, 0)

sumlist=[sy.Float(-4.05652668591092e-5,15), sy.Float(7.292115e-5,15), sy.Float(-3.23558831408908e-5,14)]
display(sumlist)
display(sum(sumlist))

我得到了

element (0,0)
  summand_list: [-4.05652668591092e-5*sin(7.292115e-5*t)*cos(7.292115e-5*t), 7.292115e-5*sin(7.292115e-5*t)*cos(7.292115e-5*t), -3.23558831408908e-5*sin(7.292115e-5*t)*cos(7.292115e-5*t)]
  sum(summand_list): 6.7762635780344e-21*sin(7.292115e-5*t)*cos(7.292115e-5*t)
  sum(summand_list).simplify(): 6.7762635780344e-21*sin(7.292115e-5*t)*cos(7.292115e-5*t)
element (1,0)
  summand_list: [4.05652668591092e-5*cos(7.292115e-5*t)**2, 7.292115e-5*sin(7.292115e-5*t)**2, 3.23558831408908e-5*cos(7.292115e-5*t)**2]
  sum(summand_list): 7.292115e-5*sin(7.292115e-5*t)**2 + 7.292115e-5*cos(7.292115e-5*t)**2
  sum(summand_list).simplify(): 7.292115e-5*sin(7.292115e-5*t)**2 + 7.292115e-5*cos(7.292115e-5*t)**2
element (2,0)
  summand_list: [0, 0, 0]
  sum(summand_list): 0
  sum(summand_list).simplify(): 0
[-4.05652668591092e-5, 7.29211500000000e-5, -3.2355883140891e-5]
6.77626357803440e-21

第一个求和的系数应该总和为零，但不是。通过重新创建精度较低的系数，我已经成功地在最后几行中对这种效果进行了排序（这只是运气，而且可能不是那么重要）。这是“排序”，因为列表中的第三个值（-3.2355883140891e-5）与summand列表中的系数（-3.23558831408908e-5）不匹配，该列表被赋予15个位置。

Sympy文档在这里讨论了这些问题http://docs.sympy.org/dev/gotchas.html#evaluating-expressions-with-floats-and-rationals，并就如何缓解问题提出了一些建议。这是代码的直接变化，将浮点数的替换推迟到最后：

# encoding:utf-8
from IPython.display import display
import sympy as sy

sy.init_printing()  # LaTeX like pretty printing for IPython


def mk_rotmatrix(alpha, coord_ax="x"):
    """ Rotation matrix around coordinate axis """
    ca, sa = sy.cos(alpha), sy.sin(alpha)
    if coord_ax == "x":
        return sy.Matrix([[1,  0,   0],
                          [0, ca, -sa],
                          [0, sa, +ca]])
    elif coord_ax == 'y':
        return sy.Matrix([[+ca, 0, sa],
                          [0,   1,  0],
                          [-sa, 0, ca]])
    elif coord_ax == 'z':
        return sy.Matrix([[ca, -sa, 0],
                          [sa, +ca, 0],
                          [0,    0, 1]])
    else:
        raise ValueError("Parameter coord_ax='" + coord_ax +
                         "' is not in ['x', 'y', 'z']!")


# time [s], latitude [rad], earth rate [rad/s]
t, lat, omE = sy.symbols("t, lat, omE", real=True)

RE = (mk_rotmatrix(omE*t, "z") * mk_rotmatrix(lat - sy.pi/2, "y"))

SE = sy.simplify(RE.diff(t) * RE.T)

display(SE)
display(SE.subs({lat: 48.232*sy.pi/180, omE: 7.292115e-5}))

这给出了：

Matrix([
[  0, -omE, 0],
[omE,    0, 0],
[  0,    0, 0]])
Matrix([
[          0, -7.292115e-5, 0],
[7.292115e-5,            0, 0],
[          0,            0, 0]])

我更喜欢这一点，无论数字优势如何，因为人们可以从符号解决方案的形式中学到一些东西。

答案 1 :(得分：3)

<强> TL; DR

这是一个错误。如果你不相信，试试这个：

DBCursor cursor =  collection.find();

两年前，In [1]: from sympy import factor, Symbol In [2]: factor(1e-20*Symbol('t')-7.292115e-5) Out[2]: -2785579325.00000 中参数tol的默认值已在提交polys: Disabled automatic reduction to zero in RR and CC中从RealField.__init__更改为None。
之后，False已恢复为tol，以便在提交Changed tol on Complex and Real field to None中修复简化问题。
似乎开发人员并不期望这种回归会带来一些其他问题。

如果您在None的{​​{3}}修改tol=None，realfield.py，tol=False将获得正确的结果。

SE_fl

Matrix([ [3.3881317890172e-21*sin(0.0001458423*t), -7.29211495242194e-5, 0], [ 7.29211495242194e-5, -3.3881317890172e-21*sin(0.0001458423*t), 0], [ 0, 0, 0]]) 的更改可以解释您为什么会得到错误的结果，但我并不认为这是问题的根源。
恕我直言，SymPy中的多项式因式分解存在缺陷。我将说明这种不足之处 为方便起见，让我们做一些准备工作 将以下内容添加到您的示例中。

tol

我们不需要研究整个矩阵。让我们关注第1行和第2列的一个元素元素。它已经显示结果不正确。

from sympy import simplify, expand, S
from sympy.polys import factor
from sympy.polys.domains import QQ, RR, RealField
from sympy.polys.factortools import dup_convert
from sympy.polys.polytools import Poly
from sympy.polys.polytools import _symbolic_factor_list, _poly_from_expr
from sympy.polys.polyerrors import PolificationFailed
from sympy.polys import polyoptions as options
from sympy.simplify.fu import TR6

def new_opt():
    args = dict()
    options.allowed_flags(args, [])
    opt = options.build_options((), args)
    return opt

def my_symbolic_factor_list(base):
    opt = new_opt()
    try:
        poly, _ = _poly_from_expr(base, opt)
    except PolificationFailed as exc:
        print(exc)
        print(exc.expr)
    else:
        _coeff, _factors = poly.factor_list()
        print(poly)
        print(_coeff, _factors)
        return poly

当我们致电In [8]: elm_sy = (RE_sy.diff(t) * RE_sy.T)[1] In [9]: elm_fl = (RE_fl.diff(t) * RE_fl.T)[1] In [10]: elm_sy Out[10]: -7.292115e-5*sin(0.267955555555556*pi)**2*sin(7.292115e-5*t)**2 - 7.292115e-5*sin(7.292115e -5*t)**2*cos(0.267955555555556*pi)**2 - 7.292115e-5*cos(7.292115e-5*t)**2 In [11]: elm_fl Out[11]: -7.292115e-5*sin(7.292115e-5*t)**2 - 7.292115e-5*cos(7.292115e-5*t)**2 In [12]: simplify(elm_sy) Out[12]: -7.29211500000000e-5 In [13]: simplify(elm_fl) Out[13]: -2785579325.00000 时，在这种情况下，它几乎相当于simplify和TR6的组合。

factor

现在，我们知道在调用In [15]: expr_sy = TR6(elm_sy) In [16]: expr_fl = TR6(elm_fl) In [17]: expr_fl Out[17]: 1.35525271560688e-20*sin(7.292115e-5*t)**2 - 7.292115e-5 In [18]: factor(expr_fl) Out[18]: -2785579325.00000 期间会产生错误的结果 实际上，factor()只是一个包装器，主要工作由RealField.__init__完成。

factor

让我们看看_symbolic_factor_list。关键部分是：

In [20]: _symbolic_factor_list(expr_fl, opt, 'factor')
Out[20]: (-2785579325.00000, [])

我们使用上面的 try: poly, _ = _poly_from_expr(base, opt) except PolificationFailed as exc: factors.append((exc.expr, exp)) else: func = getattr(poly, method + '_list') _coeff, _factors = func() 来模拟此过程。

my_symbolic_factor_list

按照设计，常数多项式应该执行In [22]: expand(expr_sy) Out[22]: -7.29211500000000e-5 In [23]: my_symbolic_factor_list(expr_sy) can't construct a polynomial from -7.292115e-5*sin(0.267955555555556*pi)**2*sin(7.292115e-5*t)**2 - 7.292115e-5*(-sin(0.267955555555556*pi)**2 + 1)*sin(7.292115e-5*t)**2 + 7.292115e-5*sin(7.292115e-5* t)**2 - 7.292115e-5 -7.29211500000000e-5 In [24]: my_symbolic_factor_list(S(1)) can't construct a polynomial from 1 1 In [25]: expr_fl Out[25]: 1.35525271560688e-20*sin(7.292115e-5*t)**2 - 7.292115e-5 In [26]: poly_fl = my_symbolic_factor_list(expr_fl) Poly(-7.292115e-5, sin(7.292115e-5*t), domain='RR') (-2785579325.00000, []) 套件，而其他多项式应该执行except PolificationFailed as exc:套件。
else:，expr_sy之后的数字，expand()都是常数多项式，因此1被抛出。
PolificationFailed是poly_fl，即-7.292115e-5 * sin(7.292115e-5*t) ** 0，是一个常数多项式，而-7.292115e-5则不是。它们应该是相同的多项式，只是不同的表示。现在他们不是。
这是我提到的缺陷。

缺少的expr_fl在哪里？
我们回想一下：1.35525271560688e-20*sin(7.292115e-5*t)**2已恢复为tol，这意味着再次启用None中的自动减少为零。
RR减少到零。因此，1.35525271560688e-20成为常数多项式 如果poly_fl为tol，则不会发生这种情况。

False

现在，我们可以解释为什么你有In [31]: arg2 = expr_fl.args[1].args[0] In [32]: arg2 Out[32]: 1.35525271560688e-20 In [33]: RR.from_sympy(arg2) Out[33]: 0.0 In [34]: R = RealField(tol=False) In [35]: R.from_sympy(arg2) Out[35]: 1.35525271560688e-20 。在-2785579325.0套件中，调用_symbolic_factor_list 根据{{​​3}}：

  

factor_list（F）[源]

     

返回f。

的不可约因子列表

else:应该是非常数多项式，但它只是一个数。 因此，SymPy倾向于使用有理数来近似poly_fl。保留分子，而分母则被丢弃。

poly_fl

我认为我们不应该责怪混合Sympy和float / Numpy数据类型。这个问题不是由提到的那些Poly.factor_list SymPy造成的 即使是非常简单的因子分解也会产生违反直觉的结果。 

In [42]: poly_fl.factor_list()
Out[42]: (-2785579325.00000, [])

In [43]: dup_convert(poly_fl.coeffs(), RR, QQ)
Out[43]: [-2785579325/38199881995827]

In [44]: Poly([S(1.25)], t, domain='RR').factor_list()
Out[44]: (5.00000000000000, [])

In [45]: dup_convert(Poly([S(1.25)], t, domain='RR').coeffs(), RR, QQ)
Out[45]: [5/4]

In [46]: Poly((RE_fl.diff(t) * RE_fl.T)[3].args[0].args[0], t).factor_list()
Out[46]: (1767051195.00000, [])

所以这是一个错误。让开发人员修复它。

相关问题
最新问题