Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Символьные вычисления в Python. Основы работы с библиотекой SymPy. Учебно-методическое пособие
.pdf
11
Результатом будет кортеж (х0, х1, х2), с которым можно
проводить операции, применимые к кортежам, например
операцию *: 3*x. Выполнив команды init_printing(); pprint(x) для
приведенного ранее кода, получим отображение результата
с индексами (х0, х1, х2).
Отличие функции symbols от var состоит в том, что первая функ-
ция возвращает ссылку на символьный объект в виде какой-либо переменной. Для использования в дальнейшем ее нужно присвоить конкретной переменной (например, a=symbols('err')). Функция var добавляет созданные переменные в текущее пространство имен. Синтаксис
функции аналогичен функции symbols:
from sympy import var, log
var("a b")
a**2+log(b) # a2+log(b)
В функциях symbols() и var() можно объявлять тип и накладывать
ограничения на символьные переменные. Например:
x = symbols('x', integer=True) # объявляем переменную целой
x = symbols('x', positive = True, integer=True)
x, y, z = symbols('x,y,z', real=True)
Иногда без таких ограничений на переменные очевидные преоб-
разования не работают. Так, результатом выполнения кода
from sympy import *
x=symbols('x')
abs(x+1)
будет | x+1|.
Результат изменится, если объявить х положительной
переменной:
from sympy import *
x=symbols('x', positive=True)
abs(x+1)
Результат: х+1.
Имя переменной из пространства имен можно удалить командой
del имя1, имя2,.., например del x,y.
Функции. В модуле sympy.core.function библиотеки SymPy есть
класс Function. Это базовый класс для всех математических функций. Среди
функций класса есть функции для комплексных чисел, тригонометрические
12
функции, функции для работы с целыми числами, комбинаторные и другие
функции. К функциям для работы с целыми числами относятся функции
ceiling() и floor(). Функция ceiling() возвращает самое маленькое целое
число, которое не меньше аргумента, указанного в скобках: ceiling(6.7),
ceiling(Rational(14, 3)), ceiling(-5.7), ceiling(5.1) # (7, 5, -5, 6). Функция floor()
производит округление в меньшую сторону: floor(6.7), floor(-5.7),
floor(5.1) # (6, -6, 5). Функция frac() возвращает дробную
часть числа в десятичном представлении: frac(3/4),frac(1/3),frac(4.096). Результат: (0.750000000000000, 0.333333333333333, 0.0960000000000001).
Такое число знаков после запятой появилось из-за наличия в строке бесконечной дроби 1/3.
В библиотеке есть функции упрощения: expand(), simplify(), fac-
tor(), collect(), trigsimp(), powsimp(), logcombine(), combsimp().
Функцию expand() используют, чтобы раскрыть скобки у выра-
жения, например у выражения (х+6)3:
from sympy import *
var("x")
t=(x+6)**3
t.expand()
Результат:
32
18 108 216.x x x+ + +
С помощью этой же функции можно, например, выразить tg(x+y)
через tg(x) и tg(y):
from sympy import *
var("x y")
tan(x+y).expand(trig=True)
В результате получим
tan( ) tan( )
tan( )tan( ) 1 tan( )tan( ) 1
xy
x y x y
+
− + − +
Данное выражение можно упростить, применив функцию simplify():
tan(x+y).expand(trig=True).simplify().
Для разложения многочлена на множители используют функцию
factor(). Разложим на множители многочлен
4 3 3 2 2 2 2 2 2
2 8 4 24 4 12 12 :x x y x x y x y x xy xy y+ + − + − − − +
from sympy import *
var("x y")
t= 2*x**4+x**3*y+8*x**3-x**2*y**2+4*x**2*y-\
13
24*x**2-4*x*y**2-12*x*y+12*y**2
factor(t)
Вместо последней строки можно записать t.factor()
Результат: (x−2)(x+6)(x+y)(2x−y).
Разложить многочлен на множители можно с помощью функции
factor_list(). Она возвращает список факторов (множителей) в виде кортежа вида (фактор, степень):
factor_list(t) # (1, [(x – 2, 1), (x + y, 1), (x + 6, 1), (2*x – y, 1)])
Собрать слагаемые с точностью до степеней с рациональными показателями можно с помощью функции collect():
from sympy import *
var("x y z")
t= x*y*z + x – 3 – x**2 – y**2+z**2*x**2 + x**3
t #
3 2 2 2 2
3x x z x xyz x y+ − + + − −
collect(t,x) #
3 2 2 2
( 1) ( 1) 3x x z x yz y− − + + − −
Функция collect() создает несократимую дробь
exp 1
,
exp 2
r
r
используя
в качестве аргументов рациональные функции expr1 и expr2:
from sympy import *
var("x")
expr2=x**2+2*x+1
expr1=x+1
cancel(expr1/expr2) # Результат
1
1х +
t=S(1)/3*x**2+2*x+1
cancel(expr1/t) # Результат
2
33
63
х
хх
+
++
Для упрощения выражений, содержащих тригонометрические
функции, используют функцию trigsimp():
from sympy import *
var("x y")
expr=sin(x)*cos(y)+cos(x)*sin(y)+y+2*cos(x)**2-1
trigsimp(expr) # y+sin(x+y)+cos(2x)
14
Упростить математические выражения, содержащие степени,
можно с помощью функции powsimp():
from sympy import *
var("x")
t=x**2*x**3.+x**1.5*x*x**2.5
powsimp(t) # Результат 2x
5.0
Комбинаторные выражения, включающие факториал и биномы,
можно упростить с помощью функции combsimp(). В SymPy есть функция factorial(), с помощью которой вычисляют факториал от числа, стоящего в скобках, и функция binomial(n,m), вычисляющая
!
.
!( )!
m
n
n
C
m n m
=
−
Обозначение этого выражения в SymPy
.
n
m
Вычис-
лим, например,
!
:
( 2)!
х
х −
from sympy import *
var("x")
t=factorial(x)/factorial(x-2)
t # Результат
!
( 2)!
х
х −
combsimp(t) # Результат x(x−1)
y=binomial(x,x-2)/binomial(x+1,x-3)
Результат:
2
1
3
x
x
x
x
−
+
−
, где в числителе и в знаменателе указано
число сочетаний из x по (x-2) и из (x+1) по (x-3) соответственно.
combsimp(y) # Результат
12
( 2)( 1)хх−+
Для упрощения выражений, содержащих логарифмы, исполь-
зуют функцию logcombine():
from sympy import *
var("x y a b")
z=log(x)-a*log(x)+b*log(x*y)
z # Результат −alog(x)+blog(xy)+log(x)
logcombine(z) # Результат log(xx-a(xy)b)
15
Для разложения выражения на дроби используют функцию
apart(expr,x). Разложим, например, на дроби выражение
2
1
:
32хх++
from sympy import *
var("x");t=1/(x**2+3*x+2);z=apart(t,x);z
11
21xx
−+
++
Чтобы привести дробь к одному знаменателю, используют функ-
цию together(expr,x). Привести к общему знаменателю сумму
2
23
:
3 2 2
xx
x
x x x
+
++
− + −
from sympy import *
var("x");together(x+(2*x+3)/(x**2-3*x+2)+x/(x-2))
22
2
( 2)( 3 2) ( 3 2) ( 2)(2 3)
( 2)( 3 2)
x x x x x x x x x
x x x
− − + + − + + − +
− − +
Очевидно, что полученное выражение можно упростить. Это де-
лается с помощью функции simplify():
from sympy import *
var("x");w=together(x+(2*x+3)/(x**2-3*x+2)+x/(x-2)).simplify();w
Вместо последней строки можно записать:
w=together(x+(2*x+3)/(x**2-3*x+2)+x/(x-2));simplify(w)
В обоих случаях получим
32
2
2 3 3
.
32
x x x
xx
− + +
−+
Для вычисления значения символьного выражения применяют
функцию evalf(), которая преобразует выражение в число с плавающей
точкой. В скобках указывается необходимое число значащих цифр:
from sympy import pi,E;d=pi**2+E;d.evalf(5)
12.588
Операции с символьными переменными. Одной из важнейших
операций при работе с символьными переменными является операция
подстановки subs(). С ее помощью одни переменные могут быть заменены на другие переменные, числа или выражения:
from sympy import *
var("x y z a")
t=x**2+sin(x)+y/z
t.subs(x,a+1).subs(y,1)
16
В результате в выражении t переменная х будет заменена на вы-
ражение а+1, а переменная y – на число 1:
2
1
( 1) sin( 1) .aa
z
+ + + +
Аргумент метода subs() может быть последовательностью, которая должна содержать пары (старое значение, новое значение), а может
быть символьным выражением, поэтому проведенные в предыдущем
примере замены можно было провести таким образом:
from sympy import *
var("x y z")
t=x**2+sin(x)+y/z
t.subs([(x,a+1),(y,1)]) # выполнена подстановка x=a+1, y=1
С помощью этой функции можно вычислить значение выражения
при конкретных значениях переменных, использовав в качестве выражения в скобках структуру данных словарь:
from sympy import *;
a, b, c= symbols('a:c');
expr=a+b**2+sin(c);
expr.evalf(5, subs={a: 100, b: 3, c: pi/4}) # 109.71
Вместо последней строки можно написать:
expr.subs({a: 100, b: 3, c: pi/4}).evalf(5)
Подстановки выполняются последовательно. В приведенном коде
from sympy import *
var("x y")
z=x**2+x/y+y**5
d=z.subs([(x,y),(y,x)]);d
сначала переменная x заменяется на y. Получается d=y2+y/y+y5=
=y2+1+y5. Затем переменная y заменяется на x. Получается d=х2+1+х5.
Если мы просто хотим получить выражение d=y2+y/x+x5, это можно
сделать, добавив еще один параметр в функцию subs():
simultaneous=True. Замены будут проведены одновременно:
from sympy import *
var("x y")
z=x**2+x/y+y**5
d=z.subs([(x,y),(y,x)],simultaneous=True) ;d
Результат:
52
.
y
xy
x
++
17
Можно функцию или переменную заменить на другую функцию
или переменную:
from sympy import *
var("x y")
z=x**2+x/y+y**5
d=z.subs(x,sin(y));d
Результат:
52
sin( )
sin ( ) .
y
yy
y
++
Вычислить значение символьного выражения можно с помощью
функции lambdify(), которая переводит выражения SymPy в функции
Python. lambdify действует как лямбда-функция с тем исключением, что
она конвертирует SymPy в имена числовой библиотеки, обычно NumPy.
По умолчанию же она реализована на основе стандартной библиотеки
math. Пример работы функции lambdify, содержащей три аргумента:
from sympy import *
a, b, c= symbols('a:c');
expr=a+b**2+sin(c);
f = lambdify([a,b,c], expr)
f(100,3,3.1415/4) # 109.70709040200144
Модуль assumptions в SymPy включает инструменты для получения информации о выражениях. Для этого используется функция ask().
Можно получить информацию о том, является ли число алгебраическим (algebraic(x)), комплексным (complex(x)), составным
(composite(x)), четным (even(x)) или нечетным (odd(x)), мнимым
(imaginary(x)), целым (integer(x)), рациональным (rational(x)) или иррациональным (irrational(x)), положительным (positive(x)) или отрицательным (negative(x)), равным (positive(x)) или не равным нулю (nega-
tive(x)):
from sympy import *
ask(Q.algebraic(pi)) # False
x, y = symbols("x y")
x,y=7, 15
ask(Q.composite(x)), ask(Q.composite(y)) # (False, True)
ask(Q.rational(x)) # True
ask(Q.zero(x)) # False
18
Более подробную информацию о функции ask() можно найти
в работе С. Ю. Борю1.
Логические выражения. Булевы функции расположены в модуле sympy.basic.booleanarg. Их можно создать и с помощью стандартных операторов Python: & (And), | (Or), ~ (Not) и т. д. Булевы выражения
наследуются от класса Basic.
Функция логического И (AND) анализирует два аргумента и воз-
вращает «ложь», если хотя бы один из них является «ложью». Эта функ-
ция заменяет оператор &:
from sympy import *
from sympy.logic.boolalg import *
x, y = symbols('x y')
x=True
y=True
And(x,y),x,y # (True, True, True)
Функция логического ИЛИ (OR) анализирует два аргумента и воз-
вращает «истину», если хотя бы один из них является «истиной». Эта
функция заменяет оператор |:
x=True;y=False;Or(x,y),x,y # (True, True, False)
Функция отрицания Not выдает False, если аргумент принимает
значение True, и наоборот. В Python для этого используется оператор ~:
x=True;y=False;Not(x),Not(y) # (False, True)
Функция исключающего ИЛИ (XOR) возвращает True, если нечет-
ное количество аргументов является True, а остальные – False. False же
вернется в том случае, если четное количество аргументов True,
а остальные – False:
from sympy import *
from sympy.logic.boolalg import *
x,y,z = symbols('x y z')
x=True;y=False;z=True
Xor(x, y, z, y, z) # True
Xor(x, y, z, y) # False
1
Борю С. Ю. Модули и пакеты в Python: учеб.-метод. пособие для студентов естественно-научных спе-
циальностей. Запорожье: ЗНУ, 2021. 286 с.
19
Штрих Шеффера, отрицание конъюнкции NAND. Результатом
работы функции является True, если хотя бы один из аргументов равен
False, и False – если они истинные:
from sympy import *
from sympy.logic.boolalg import *
x,y,z = symbols('x y z')
x=True;y=False;z=True
Nand(x, y, z, y) # True
Функция Вебба, отрицание дизъюнкции Nor. Результатом работы
функции является False, если хотя бы один из аргументов True, или же
True, если все аргументы принимают значения False:
x=True;y=False;z=True;Nor(x, y, z) # False
Функция эквивалентности Equivalent. Эта функция возвращает
отношение эквивалентности. Equivalent(A, B) будет равно True тогда
и только тогда, когда A и B оба будут True или False. Функция вернет
True, если все аргументы являются логически эквивалентными. В противном случае функция возвращает значение False:
x=True;y=False;z=True;Equivalent(x, y, z) # False.
1.2 . С о з д а н и е м н о г о ч л е н ов Ч е б ы ш е в а , Л е ж а н д р а
и Э р м и т а
Библиотека SymPy поддерживает работу с многочленами Чебышева, Лежандра и Эрмита. Полиномы Чебышева применяются при решении задач математики и физики. В частности, они используются для
приближения функцией (рядом многочленов Чебышева) экспериментальных данных. Многочлены применяются в физике, например, для
расчета антенной решетки: мощность излучения каждой антенны рассчитывается с помощью многочленов Чебышева. Это позволяет управлять соотношением амплитуды основного и боковых лепестков. Многочлены Чебышева первого рода Tn(x) могут быть определены с помощью рекуррентного соотношения:
20
0
1
11
( ) 1
( ) .
( ) 2 ( ) ( )
n n n
Tx
T x x
T x xT x T x
+−
=
=
=−
Так,
23
2 1 0 3 2 1
( ) 2 ( ) ( ) 2 1, ( ) 2 ( ) ( ) 4 3 .T x xT x T x х T x xT x T x х х= − = − = − = −
Для нахождения полиномов Чебышева применяют функцию
chebyshevt_poly(). Выполнение приведенной программы дает полином
Чебышева 5-й степени:
from sympy import *
chebyshevt_poly(5,polys=True)
ℤ
При необходимости можно найти корни полиномов Чебышева
с помощью функции chebyshevt_root(). Найти все три корня полинома
Чебышева 3-й степени можно следующим образом:
from sympy import *
y=chebyshevt_poly(3)
y,chebyshevt_root(3,0),chebyshevt_root(3,1), \
chebyshevt_root(3,2)
(4*_x**3 – 3*_x, sqrt(3)/2, 0, -sqrt(3)/2)
В результате получили кортеж, содержащий уравнение полинома
и его корни с номерами 0, 1 и 2. Методом args можно получить список
аргументов полинома в виде кортежа y.args # (-3*_x, 4*_x**3) или
в виде отдельных слагаемых y.args[1] # 4x3.
Полиномы Лежандра Рn(x) имеют множество приложений как
в математике, например, для разложения функции в ряды полиномов
Лежандра, так и в физике, где уравнение Лежандра появляется при получении решений уравнений Лапласа или Гельмгольца в сферических
координатах. Вычислить Рn(x) можно с помощью рекуррентного соотношения:
0
1
11
( ) 1
( ) .
21
( ) ( ) ( )
11
n n n
Px
P x x
nn
P x xP x P x
nn
+−
=
=
+
=−
++
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]