Поведение Sympy Eq () и общее использование Sympy - PullRequest
Новая
       48

Поведение Sympy Eq () и общее использование Sympy

0 голосов
/ 29 апреля 2019

В случае Eq(lhs,rhs) можно создать уравнение. Однако я действительно очень интересуюсь его поведением и хотел бы спросить, как это уравнение тип предназначен для использования!

Причина, по которой я спрашиваю, состоит в том, что в Maple каждый использует уравнения (lhs == rhs) в качестве стандартного инструмента. Тем не менее, я видел много скриптов в sympy, использующих x= y+z, где x - это переменная python и, следовательно, код, и только выражение y+z является реальной математикой для sympy. Это имеет последствия для следующих примеров:

MWE: 

t = S('t')
f = Function('f')(t)
g = Function('g')(t)

equation = Eq(f,g+1)
equation2 = equation-1
equation3 = equation.diff(t)
equation4 = equation.subs(equation) # this I can do with subs(*equation.args)

Все вышеперечисленное дает неожиданные результаты: первый дает уравнение в скобках минус 1, что действительно странно. Дифференциация действует только на lhs, что вводит в заблуждение imho. Подстановка выдает ошибку, работает только закомментированная строка. Это последнее хорошо для меня, зная, что я могу заставить его работать. Однако есть ли более полезные обозначения для 1 и 2, кроме как делать все вручную, например: 

eq2 = Eq( equation.lhs.difft(t), equation.rhs.diff(t) )

Для сравнения Maple может заменять, выводить и добавлять уравнения в математическом смысле (необходимо учитывать обе стороны).

Буду рад любой информации о том, как "правильно" работать в sympy. В настоящее время кажется, что работа с rhs-выражениями - это только путь, а Eq - «побочный проект». Спасибо за каждый вклад в этом!

1 Ответ

0 голосов
/ 29 апреля 2019

В сеансе isympy: 

In [3]: t = S('t') 
   ...: f = Function('f')(t) 
   ...: g = Function('g')(t)                                                         

In [4]: equation = Eq(f, g+1)                                                        

In [5]: equation                                                                     
Out[5]: f(t) = g(t) + 1

type(equation) - это sympy.core.relational.Equality.

= в Out[5] не относится к питону = в In[4] строке. 

In [6]: equation2 = equation-1                                                       

In [7]: equation2                                                                    
Out[7]: -1 + (f(t) = g(t) + 1)

Здесь type отличается: sympy.core.add.Add

In [8]: equation3 = equation.diff(t)                                                 

In [9]: equation3                                                                    
Out[9]: 
d                  
──(f(t) = g(t) + 1)
dt

Это sympy.core.function.Derivative. Это похоже на неоцененную производную, применяя ко всему объекту equation.

Ошибка в выражении subs является просто неправильным использованием subs. Почему вы пытаетесь использовать equation в качестве аргумента метода? 

In [10]: equation4 = equation.subs(equation)                                         
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-10-b6a4334b7078> in <module>
----> 1 equation4 = equation.subs(equation)

/usr/local/lib/python3.6/dist-packages/sympy/core/basic.py in subs(self, *args, **kwargs)
    865                    When a single argument is passed to subs
    866                    it should be a dictionary of old: new pairs or an iterable
--> 867                    of (old, new) tuples."""))
    868         elif len(args) == 2:
    869             sequence = [args]

ValueError: 
When a single argument is passed to subs it should be a dictionary of
old: new pairs or an iterable of (old, new) tuples.

Правильное использование subs: 

In [15]: equation4 = equation.subs([(t,t*2)])                                        

In [16]: equation4                                                                   
Out[16]: f(2⋅t) = g(2⋅t) + 1

====

Ссылка для Eq:

https://docs.sympy.org/latest/modules/core.html?highlight=eq#sympy.core.relational.Equality

Я все еще работаю над документацией sympy, но мне не кажется, что Eq создает equation в обычном алгебраическом смысле. Это скорее тест между двумя объектами, который оценивается как True или False или остается неоцененным.

Заменив f на g, мы получим отношение, которое можно оценить: 

In [26]: equation.subs([(f,g)])    # or subs(f,g)                                                  
Out[26]: False

Те же значения в equation2 и equation3 выдают ошибку (невозможно добавить число и False) или производную от False. То есть подстановка выполняется в части equation, вычисляя до False, и выполняется сброс выражения (или нет).

Ваше использование *equation.args соответствует этому шаблону: 

In [43]: equation.args                                                               
Out[43]: (f(t), g(t) + 1)

In [44]: equation.subs(*equation.args)                                               
Out[44]: True

===

https://docs.sympy.org/latest/gotchas.html предлагает альтернативу Eq(x,y) x-y: 

In [31]: eq1 = f - (g+1)                                                             

In [32]: eq1-1                                                                       
Out[32]: f(t) - g(t) - 2

In [33]: eq1.diff(t)                                                                 
Out[33]: 
d          d       
──(f(t)) - ──(g(t))
dt         dt      

In [41]: equation.subs([(f,g)])                                                      
Out[41]: False

In [42]: equation.subs([(f,g+1)])                                                    
Out[42]: True
...