Символьные вычисления средствами Python. Часть1. Основы

При решении задач математического моделирования процессов и объектов часто очень практично использовать алгоритмы на языке Python с использованием символьных вычислений. Основываясь на библиотеке SymPy, Python с успехом справляется с решением уравнений и систем, интегрированием и дифференцированием, вычислением пределов, разложением в ряд и суммированием рядов, упрощением выражений, выполняет поиск решения дифференциальных уравнений и систем.

При использовании символьных вычислений пользователю предоставляется возможность управлять работой программы в процессе ее исполнения путём ввода любых допустимых функций с заданным количеством переменных.

Как преподаватель дисциплины «Компьютерная техника и программирование», в модуле, посвященном программированию на языке Python, я знакомлю студентов с возможностями этого языка для научных исследований. Вашему вниманию представляется цикл статей, в которых можно ознакомиться с символьными вычислениями на Python. Хочу сразу предупредить, что данные статьи не претендуют на абсолютную уникальность, так как собраны на основании материалов из различных источников, их цель – обучить студентов основам символьных вычислений.

Самым первым шагом на пути к символьным вычислениям является импортирование функций модуля SymPy с помощью pip, системы управления пакетами Python. Если вы с этим справились, сразу перейдем к объявлению переменных.

Примечание. Для сокращения записи во всех следующих примерах не приводится первая строка: from sympy import *

Явное объявление символьных переменных

Для символьных вычислений с помощью модуля SymPy символьные переменные и функции должны быть объявлены как таковые. В программах для математических вычислений, таких как Mathematica или Maple, переменные сразу рассматриваются как символьные. В Python же их необходимо принудительно объявить символьными, и сделать это можно несколькими путями. Самым простым будет использование функций symbols() или var(). Первая функция возвращает ссылку на символьный объект в виде какой-либо переменной. Вторая, без присваивания создает символьную переменную.


Главное отличие между функциями symbols() и var() состоит в том, первая функция возвращает ссылку на символьный объект. Для использования в дальнейшем, ее нужно присвоить какой-либо переменной. Вторая, без присваивания, создает символьную переменную.
В функциях symbols() и var() можно объявлять символьные переменные с индексом:


Также можно назначить тип и накладывать ограничения на символьные переменные прямо в функциях symbols() и var(). Иногда без таких ограничений очевидные преобразования не работают, например, сравните:


Чтобы создать контейнер для одиночного символа, используем аргумент seq=True:

>>> symbols('x',seq=True)
(x,)

Определение действительных значений для символьных переменных:

>>> x, y, z = symbols('x,y,z', real=True)
>>> x.is_real and y.is_real and z.is_real
True

Функция S()

Иногда символьные выражения могут быть проинтерпретированы как числовые константы Python, а не SymPy. Поэтому для объявления символьных переменных, а также для преобразования числовых констант в символьные, применяют функцию S(), например, сравним:

>>> expr = x**2 + sin(y) + S(10)/2; expr
x**2 + sin(y) + 5 
>>> type(10)
<class 'int'>
>>> type(S(10)) # символьная константа десять
<class 'sympy.core.numbers.Integer'>

Разница между постоянной Python и символьной состоит в том, что символьная константа может быть вычислена с заданной степенью точности, как показано в следующем примере в сравнении со стандартной функцией round():

z=1/7; z # вычисляет переменную z с процессорной точностью
0.14285714285714285
z1=S(1)/7; z1
1/7
z2=z1.n(30); z2 # вычисляет переменную z2 с точностью до 30 значащих цифр
0.142857142857142857142857142857
z3=round(z1,30); z3
0.14285714285714285

Cимвольные имена

Если в текущей сессии необходимо использовать символьную математику постоянно, то можно импортировать общепринятые символьные имена из модуля sympy.abc:


Имя переменной из пространства имен можно удалить командой del имя1, имя2,..:

>>> type(x)
<class 'sympy.core.symbol.Symbol'>
>>> del x,y 
>>> x
NameError: name 'x' is not defined 

Для восстановления значений стандартных констант, а также имен некоторых функций, нужно повторно загрузить модуль sympy.

>>> from sympy import *

Метод subs(...)

Следует помнить, что при записи символьного выражения может автоматически выполняться его упрощение, например:

>>> a,b,c,d,x,y,z,u,v,w = symbols('a b c d x y z u v w') 
>>> x - z + 20 -z- 15 + 3*sin(pi/2)+2*z
x + 8

Метод subs(...) используется для вычисления символьного выражения при заданных значениях переменных, например:

>>> a, x = symbols('a x')
>>> f= a**3*x + 3*a**2*x**2/2 + a*x**3 + x**4/4 
>>> f.subs(a,1) # в выражение f вместо переменной a была подставлена единица
x**4/4 + x**3 + 3*x**2/2 + x

Если в методе subs использовать два аргумента, то они интерпретируются как subs(old,new), т.е. старый идентификатор old заменяется новым new. Аргумент метода subs() может быть последовательностью, которая должна содержать пары (old,new), а может быть символьным выражением, например:

>>> a,b,c,d,x,y,z = symbols('a b c d x y z')
>>> f=a*x**3 +b*y**2 + c*z+d
>>> f.subs([(a,1),(b,2),(c,3),(d,4)]) # выполнена подстановка a=1, b=2, c=3, d=4
x**3 + 2*y**2 + 3*z + 4
>>> pr= x**3+4*x**2+6*x+10 
>>> pr.subs(x,1/x) # выполнена подстановка символьного выражения
10 + 6/x + 4/x**2 + x**(-3)

Обратим ваше внимание на следующую особенность работы с переменными (символьными и обычными переменными Python). Выполним следующий код:

>>> x='Hello' 
>>> pr=x+'world' 
>>> pr 
'Helloworld' 
>>> x='AAA' #присвоили символьной переменной x новое значение
>>> pr
'Helloworld'

Здесь действует правило: если переменная изменилась, то созданное ранее выражение, содержащее эту переменную, не пересчитывается автоматически. Это правило срабатывает и для обычных переменных Python.

Операции с дробями

Модуль SymPy может проводить вычисления с дробями и приводить их к общему знаменателю, например, сравните:

>>> S(1)/3+S(2)/5
11/15 
>>> 1/3+2/5
0.7333333333333334

Функции Rational(числитель, знаменатель) и Integer(...) используются для создания рациональных дробей без десятичного округления:

>>> z=Rational(1, 7)+Rational(2, 5); z 
19/35
>>> Integer(1)/Integer(5)
1/5
>>> 1/5
0.2
>>> z=Integer(1)/Integer(5)+Rational(2, 7); z
17/35

Округления вычислений

В символьных вычислениях работает правило – если ничего не сказано, не делать никаких округлений. Посмотрите, как в первом случае Python преобразует выражение, но оставит в записи ответа квадратный корень и не выполнит никаких округлений, а во втором, так как одно из чисел задано с десятичной точкой, результат будет приближенным:

>>> sqrt(20)  
2*sqrt(5)
>>> sqrt(20.0) # в выражении используется число с десятичной точкой
4.47213595499958

Для любого символьного объекта существует метод evalf(...)(evaluate float), который возвращает его десятичное представление:

>>> sqrt(20).evalf()  # функция sqrt() модуля sympy
4.47213595499958
>>> E.evalf()
2.71828182845905

В методе evalf([n,...]) можно использовать аргумент, задающий точность результата (n = количество значащих цифр)

>>> sqrt(20).evalf(30)
4.47213595499957939281834733746
>>> pi.evalf(20)
3.1415926535897932385

Также всегда нужно помнить, что вещественная арифметика не возвращает точный результат, сравните:

>>> from sympy import *
>>> one=S('one')
>>> one = cos(1)**2 + sin(1)**2 
>>> one.evalf() # равно 1
1.00000000000000
>>> (one-1).evalf() # должно быть равно 0
-0.e-124 

Если известно, что результат содержит погрешность вычислений, то с помощью опции chop=True метода evalf() ее можно удалить. Очень маленькое значение вещественной или мнимой части результата в этом случае заменяется нулем. Возьмем предыдущий пример:

>>> (one-1).evalf() # должно быть равно 0
-0.e-124 
>>> (one - 1).evalf(chop=True)
0

Бесконечность

После выполнения первой строки from sympy import * становится доступен символ бесконечности – oo (две буквы „o‟), с которым тоже можно выполнять определенные операции:

>>> oo+1
oo
>>> 1000000<oo
True
>>> 1/oo
0

Символ бесконечности в основном используется функциями limit() и integrate() при задании пределов интегрирования, о чем мы поговорим в одной из следующих статей.

Вывод

Рассмотренные в статье символьные вычисления отличаются от числовых методов тем, что результаты можно и дальше исследовать, например, определять экстремумы функций, решать уравнения со вложенными переменными и так далее.

Надеюсь, моя статья будет полезна всем интересующимся программированием на языке Python, студентам и тем, кто занимается научными исследованиями.