问将"cls=sympy.Function“参数生成的符号转换为正常符号
EN

Stack Overflow用户

提问于 2018-04-04 01:27:36

回答 1查看 450关注 0票数 1

我想用sympy来求解一个非线性方程组。不幸的是，这是我的计划

import sympy
x = sympy.Symbol('x')
f,g,h= sympy.symbols("f g h", cls=sympy.Function)
#here I do some computations to arrive at the equations below
eq1 = 2*f(x)*g(x)-h(x)
eq2 = f(x)**2+h(x)*g(x)
system = [eq1,eq2]
unknowns = [f(x),h(x)]

我想为f(x)和h(x)解决这个玩具示例，但是sypmy.nonlinsolve(system,unknowns)不能工作，因为它期望系统和未知的是symbol类型，而不是Function类型。

有没有一种简单的方法可以将system和unknowns转换成这样的类型？我的意思是，如果上面的代码

import sympy
x = sympy.Symbol('x')
f,g,h= sympy.symbols("f g h")
#here I do some computations to arrive at the equations below
eq1 = 2*f*g-h
eq2 = f**2+h*g
system = [eq1,eq2]
unknowns = [f,h]

这会很完美的。我如何将f,g,h转换成这样的类型？

(使用第二段代码不是一个选项，因为我是通过使用微分来得到这些方程的，所以我需要cls=sympy.Function参数；或者，如果有人知道如何使用symbols进行微分，那么我就可以使用第二个代码版本了，这也是可行的。)

type-conversion

sympy

回答 1

Stack Overflow用户

回答已采纳

发布于 2018-04-04 07:13:33

几种解决办法：

使用开发版的SymPy

在开发版本(GitHub)中，这是开箱即用的；它在内部用符号替换函数。

>>> sympy.nonlinsolve(system, unknowns)
{(0, 0), (-2*g(x)**2, -4*g(x)**3)}

使用解

solve已经在当前发行版SymPy 1.1.1中执行函数符号交换。

sympy.solve(system, unknowns)

返回[(0, 0), (-2*g(x)**2, -4*g(x)**3)]

从recast_to_symbols的未来借用SymPy

在开发版本中，替换逻辑被隔离到recast_to_symbols函数中。

from sympy.solvers.solvers import recast_to_symbols
e, s, d = recast_to_symbols(systems, unknowns)
print(e, s, d)

版画

[2*_X0*g(x) - _X1, _X0**2 + _X1*g(x)] [_X0, _X1] {_X0: f(x), _X1: h(x)}

这是新的方程式，是新的符号，还有恢复原始事物的字典。这个想法是人们可以用

sympy.nonlinsolve(e, s).xreplace(d)

找到解决办法。(实际上，您的示例xreplace甚至不需要，因为解决方案不包含任何已替换的符号。)

如果不想使用开发版本，一个简单的解决方案是从GitHub上的源复制函数

def recast_to_symbols(eqs, symbols):
    """Return (e, s, d) where e and s are versions of eqs and
    symbols in which any non-Symbol objects in symbols have
    been replaced with generic Dummy symbols and d is a dictionary
    that can be used to restore the original expressions.
    Examples
    ========
    >>> from sympy.solvers.solvers import recast_to_symbols
    >>> from sympy import symbols, Function
    >>> x, y = symbols('x y')
    >>> fx = Function('f')(x)
    >>> eqs, syms = [fx + 1, x, y], [fx, y]
    >>> e, s, d = recast_to_symbols(eqs, syms); (e, s, d)
    ([_X0 + 1, x, y], [_X0, y], {_X0: f(x)})
    The original equations and symbols can be restored using d:
    >>> assert [i.xreplace(d) for i in eqs] == eqs
    >>> assert [d.get(i, i) for i in s] == syms
    """

    from sympy import Dummy, Symbol
    from sympy.core.compatibility import iterable

    if not iterable(eqs) and iterable(symbols):
        raise ValueError('Both eqs and symbols must be iterable')
    new_symbols = list(symbols)
    swap_sym = {}
    for i, s in enumerate(symbols):
        if not isinstance(s, Symbol) and s not in swap_sym:
            swap_sym[s] = Dummy('X%d' % i)
            new_symbols[i] = swap_sym[s]
    new_f = []
    for i in eqs:
        try:
            new_f.append(i.subs(swap_sym))
        except AttributeError:
            new_f.append(i)
    swap_sym = {v: k for k, v in swap_sym.items()}
    return new_f, new_symbols, swap_sym