Введение в научный Python-1. Введение в научный Python

• Название: Введение в научный Python
• Дата: 09.01.2020
• Размер: 6.2 Mb.
• Имя файла: Введение в научный Python-1.pdf
• Тип: Документы; #103229
• страница: 17 из 22

5.3
Реализация основных понятий математического анализа
Кроме символьных алгебраических преобразований функции пакета SymPy умеют выполнять многие операции математического анализа.
Вычисление
пределов.
Для аналитического вычисления пределов используется функция limit(...).
>>> from sympy import *
>>> x,y,z=symbols(„x y z‟)
>>> limit(sin(x)/x, x, 0)
1

194
>>> limit(x*log(x),x,0)
0
Для записи символа
∞
(бесконечность) в пакете SymPy используется запись oo (
две буквы „o‟).
>>> expr = x**2*exp( -x)
>>> limit(expr, x, oo)
0
>>> limit((1+z/x)**x,x,oo) exp(z)
>>> limit((sin(x+z) -sin(x))/z,z,0)
# производная sin(x) cos(x)
У limit()есть невычисляемый эквивалент – оператор Limit(), который возвращает символьный объект типа 'sympy.series.limits.Limit'
(невычисленный предел).
>>> expr = Limit((1 -cos(x))/x**2, x, 0)
>>> expr
Limit((-cos(x) + 1)/x**2, x, 0)
Для вычисления символьного объекта, созданного невычисляемым оператором, нужно использовать метод doit().
>>> expr.doit()
1/2
Для вычисления одностороннего предела следует передать в функцию limit() еще один аргумент „+‟ или „-„.
>>> limit(1/x, x, 0, '+') oo
>>> limit(1/x, x, 0, ' -')
-oo
>>> limit(tan(x),x,pi/2,' -') oo
Дифференцирование. Для символьного дифференцирования предназначена функция diff(...). Первым аргументом она принимает символьное выражение, которое будет дифференцироваться, а вторым – переменную, по которой вычисляется производная.
>>> from sympy import *
>>> diff(sin(x)*exp(x), x) exp(x)*sin(x) + exp(x)*cos(x)
Часто полезно использовать функцию «милой» печати pprint(), которая, в зависимости от используемой среды выполнения, пытается отобразить результат в привычном математическом виде.
>>> pprint(diff(sin(x)*exp(x), x))
# в среде IDLE
x x e *sin(x)+e *cos(x)
В IPython console Spyder и Jupyter Notebook функция pprint() результат выводит еще «милее».

195
Функцию diff() можно использовать для вычисления производных второго и более высокого порядков.
>>> diff(x**4, x, x)
# два раза дифференцируем по x
12*x**2
>>> diff(x**4, x, 3)
# третья производная по x
24*x
Можно дифференцировать выражение по нескольким переменным, т.е. вычислять смешанные частные производные.
>>> f = exp(x*y**2)
#
 
2
,
y
x
e
y
x
f

>>> diff(f, x, y)
#
y
x
f



2 2*y*(x*y**2 + 1)*exp(x*y**2)
>>> diff(f, x, 3,y, 2)
#
2 3
5
y
x
f



2*y**4*(2*x**2*y**4 + 13*x*y**2 + 15)*exp(x*y**2)
В следующем примере мы вычисляем градиент функции 3–х переменных.
>>> x,y,z=symbols('x y z')
>>> f=x**2+y**2+z**2
>>> g=[diff(f,var) for var in [x,y,z]]; g
[2*x, 2*y, 2*z]
У символьных выражений есть также метод diff().
>>> f.diff(x,2,y)
#
y
x
f



2 3
2*y**3*(x*y**2 + 2)*exp(x*y**2)
Оба способа вычисления производных эквивалентны.
У diff()есть невычисляемый эквивалент – оператор Derivative(). Он возвращает выражение типа 'sympy.core.function.Derivative'.
>>> f1=Derivative(f,x,y,y); f1
#
2 3
y
x
f



Derivative(exp(x*y**2), x, y, y)
Чтобы вычислить выражение, созданное невычисляемым оператором, нужно использовать метод doit().
>>> f1.doit()
2*(2*x**2*y**4 + 5*x*y**2 + 1)*exp(x*y**2)
Иногда полезно иметь символьные формулы, содержащие произвольные функции. Чтобы сказать системе, что переменная является именем символьной функции можно использовать инструкцию f = Function('f')
После этого идентификатор f становится именем функции и с ним можно выполнять операции, определенные для функций. Следующие несколько примеров мы выполним в IPython console в интегрированной среде Spyder, и приведем результат в таком виде, в котором он возвращается в Latex режиме.

196
Чтобы включить этот режим в IPython следует выполнить инструкцию init_printing(use_latex=True)
. В IDLE Python результат будет возвращаться в текстовом виде, поскольку Latex режим не поддерживается. from sympy import * init_printing(use_latex=True) f=Function('f') f(x).diff(x)
Другой способ создать символьные функции состоит в использовании функции symbols() с опцией cls=Functions. f, g, h = symbols('f g h', cls=Function)
Получим некоторые классические формулы дифференцирования.
(f(x)*g(x)*h(x)).diff(x) diff(f(x)/g(x),x)
Вот как можно продифференцировать сложную функцию. diff(exp(f(x)),x)
Символьная функция может иметь несколько аргументов. f(x,y).diff(x,2) f(x,y).diff(x,y)
Пример. Найдем максимум функции
 
x
x
x
x
f



2 3
2
Вначале определим экстремальные точки функции, приравняв нулю ее производные. Затем вычислим значения вторых производных в экстремальных точках. x=symbols('x') f=x**3-2*x**2+x f1=diff(f,x);f1 sols=solve(f1,x); sols
[1/3, 1] diff(f1,x).subs({x:sols[0]})
-2
diff(f1,x).subs({x:sols[1]})
2
В точке 1/3 вторая производная отрицательна, а это означает, что это точка максимума. Т.о. локальный максимум равен
>>> f.subs({x:sols[0]})
4/27

197
Интегрирование. Для символьного интегрирования предназначена функция integrate(...). С ее помощью можно вычислять как определенные, так и неопределенные интегралы. Первым аргументом она принимает символьное выражение, которое будет интегрироваться, вторым – переменную интегрирования или кортеж, состоящий из имени переменной и ее нижнего и верхнего предела. Если второй аргумент – имя, то вычисляется неопределенный интеграл, т.е. первообразная подынтегральной функции.
>>> from sympy import *
>>> x,y,a,b = symbols('x y a b')
>>> integrate(1/x, x) log(x)
>>> integrate(cos(x)**2, x) x/2 + sin(x)*cos(x)/2
>>> integrate(log(x), x) x*log(x) – x
Проверим результат дифференцированием.
>>> _.diff(x) log(x)
Обратите внимание, что SymPy не включает в результат постоянную интегрирования. Вы можете добавить константу самостоятельно, или можете сформулировать задачу как решение соответствующего дифференциального уравнения (ОДУ). Во втором случае произвольная постоянная будет включаться в результат.
Подынтегральное выражение может содержать несколько символьных переменных, по одной из которых будет выполняться интегрирование.
>>> x,y,a,b = symbols('x y a b')
>>>
y=integrate((a+x)**3, x)
>>> pprint(y)
2 2 4 3 3*a *x 3 x a *x + ------- + a*x + --
2 4
Чтобы увидеть выражение в более привычном виде, мы использовали функцию pprint(...). В зависимости от используемой вами оболочки, результат может выглядеть более привычно, например, так
Если первообразную не удалось найти, то возвращается невычисляемый объект Integral.
>>> integrate(x**x, x)
Integral(x**x, x)
Для вычисления определенного интеграла в функцию integrate() вторым аргументом нужно передать кортеж вида (var,lower_limit,upper_limit), содержащий имя переменной интегрирования var, а также нижний lower_limit и верхний upper_limit пределы интегрирования.

198
>>> integrate(sin(x), (x, 0, pi))
#


0
sin
x
d
x
2
Аналогично вычисляются несобственные интегралы с бесконечными пределами интегрирования.
>>> integrate(exp(-x), (x, 0, oo))
#



0
x
d
e
x
1
Здесь вместо символа
∞
нужно вводить oo (две буквы „o‟).
>>> integrate(exp(-x**2), (x, -oo, oo))
#





x
d
e
x
2
sqrt(pi)
Функцию integrate() можно использовать для вычисления повторных интегралов.
>>> integrate(x*y,x,y)
#




 

y
d
x
d
y
x
x**2*y**2/4
>>> integrate(x*y,(x,0,1),(y,0,1))
#
 
 






1 0
1 0
y
d
x
d
y
x
1/4
>>> integrate(exp(-x**2-y**2),(x,-oo,oo),(y,-oo,oo))
#
 








y
xd
d
e
y
x
2 2
pi
Внутренние пределы интегрирования могут зависеть от переменной интегрирования внешнего интеграла. Вот пример вычисления повторного интеграла по верхней половине единичного круга.
>>> integrate(x**2*y,(y,0,sqrt(1-x**2)),(x,-1,1))
#




1 1
1 0
2 2
x
y
d
y
x
x
d
2/15
У integrate()есть невычисляемый эквивалент – функция Integral(). Она возвращает объект типа 'sympy.integrals.integrals.Integral'. Чтобы потом вычислить интеграл, нужно использовать метод doit().
>>> expr = Integral(log(x)**2, x); expr
Integral(log(x)**2, x)
>>> expr.doit() x*log(x)**2 - 2*x*log(x) + 2*x
Суммы и ряды. Для символьного вычисления конечных и бесконечных сумм используется функция summation. В формате summation(f,(i,imin,imax)) она вычисляет сумму вида
 


max min
i
i
i
i
f
(приращение индекса i равно 1).
>>> var('i,j,n')

199
>>> summation(2*i-1,(i,1,12))
144
>>> summation((i+j)**2,(i,1,3),(j,1,4))
266
Пределы суммирования могут быть символьными.
>>> var('a,b')
>>> s = summation(6*n**2 + 2**n, (n, a, b)); s
-2**a+2**(b + 1)-2*a**3+3*a**2-a+2*b**3+3*b**2+b
Можно суммировать выражения, содержащие более чем одну переменную; другие переменные будут трактоваться, как константы.
>>> summation(x**i/factorial(i),(i,1,7)) x**7/5040 + x**6/720 + x**5/120 + x**4/24 + x**3/6 + x**2/2 + x
Результат вычисления суммы может быть преобразован в более простое выражение.
>>> summation(i**2, (i, 1, n)) n**3/3 + n**2/2 + n/6
>>> summation(i**4,(i,1,n)) n**5/5 + n**4/2 + n**3/3 - n/30
>>> factor(_) n*(n + 1)*(2*n + 1)*(3*n**2 + 3*n - 1)/30
>>> simplify(summation(( -1)**i*i/(4*i**2 -1),(i,1,n)))
((-1)**n - 2*n - 1)/(4*(2*n + 1))
Пределы суммирования могут быть бесконечными. Такие суммы принято называть рядами и SymPy умеет их вычислять.
>>> summation(1/i**2,(i,1,oo)) pi**2/6
>>> summation(x**n/factorial(n),[n,0,oo]) exp(x)
Если найти результат суммирования в символьной форме не удается, SymPy возвращает невычисляемую форму оператора суммирования Sum().
>>> summation(i/(1+factorial(i)),(i,1,oo))
Sum(i/(factorial(i) + 1), (i, 1, oo))
Невычисляемую форму можно использовать сразу, чтобы впоследствии использовать метод doit().
>>> sn = Sum(1/i**2, (i, 1, n))
>>> sn.doit()
harmonic(n, 2)
>>> limit(sn.doit(), n, oo) pi**2/6
Но вычисление предела эквивалентно вычислению бесконечной суммы.
>>> summation(1/i**2, (i, 1, oo)) pi**2/6
SymPy умеет разлагать функции в степенные ряды. Для построения разложения функции (выражения) f(x) в ряд в окрестности точки x=x
0
до слагаемых порядка (x-x
0
)
n предназначена функция series(expr[, x=None, x0=0, n=6,...])

200 и метод f(x).series(x[,x0=0,n=6]). Если x0 и n опущены, то им по умолчанию присваиваются значения x0=0 и n=6.
>>> g=series(exp(x)) ; g
1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)
>>> sin(x).series(x,0,7) x - x**3/6 + x**5/120 + O(x**7)
>>> log(x).series(x,1,4)
-1-(x - 1)**2/2+(x - 1)**3/3+x+O((x-1)**4,(x,1))
В IPython console Spyder последняя инструкция возвращает результат в виде
Чтобы не выводить остаточный член O(...), можно использовать метод expr.series(...).removeO().
>>> sin(x).series(x,0,7).removeO() x**5/120 - x**3/6 + x
Функцию series можно использовать для переразложения полинома по степеням x-a при любом a.
>>> P=x**5+2*x**4-3*x**3+6*x**2-12*x+17
>>> P.series(x,0,5)
17 - 12*x + 6*x**2 - 3*x**3 + 2*x**4 + O(x**5)
>>> P.series(x,1,5).removeO()
4*x + 7*(x - 1)**4 + 15*(x - 1)**3 + 19*(x - 1)**2 + 7
С рядами можно выполнять некоторые арифметические операции.
>>> f=series(sin(x)) ; f x - x**3/6 + x**5/120 + O(x**6)
>>> g=series(exp(x)) ; g
1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)
>>> f+g
1 + 2*x + x**2/2 + x**4/24 + x**5/60 + O(x**6)
>>> simplify(f*g) x + x**2 + x**3/3 - x**5/30 + O(x**6)
>>> simplify(g**2)
(120+120*x+60*x**2+20*x**3+5*x**4+x**5+O(x**6))**2/14400
Ряд можно дифференцировать.
>>> f.diff(x)
1 - x**2/2 + x**4/24 + O(x**5)
5.4 Графические возможности пакета SymPy
При работе с символьными функциями мы привыкли представлять их наглядно в виде графиков. В пакете SymPy имеется модуль sympy.plotting, который содержит функции, с помощью которых можно строить двумерные и трехмерные графики символьных выражений.
График функции, заданной явным уравнением y=f(x), строится с помощью функции sympy.plotting.plot(f(x)[,...]). Первый аргумент –

201 выражение f(x), график которого надо построить. Второй аргумент, если он задан, определяет интервал изменения переменной x. from sympy import symbols from sympy.plotting import plot x = symbols('x')
p1=plot(x**2,(x,-1,1))
Система автоматически выбирает масштаб по вертикальной оси и выбирает достаточное количество точек, чтобы кривая была гладкой. Параметры графика можно изменять с помощью опций: title=‟строка‟; xlabel=‟строка‟; ylabel=‟строка‟; legend=True или False; xscale=„linear‟ или 'log'; yscale=„linear‟ или 'log'; axis= True или False; axis_center=(x0,y0) или
„center‟,
„auto‟; xlim=(x min
,x max
); ylim=(y min
,y max
); aspect_ratio=(r x
,r y
) или „auto‟; autoscale=True или False; margin=float([0,1]); line_color=цвет
. Назначение большинства опций понятно из их названия. p1=plot(tan(x),(x,-3,3),ylim=( -10,10), line_color='r')
Кроме того, функция plot() возвращает объект, который имеет свои атрибуты и методы, и которые можно использовать для управления свойствами графика. p1 = plot(x**2,(x,-1,1),show=False) p1.line_color = 'cyan' p2 = plot(x**3,(x,-1,1),show=False, line_color='r')
p3 = plot(Abs( x),(x,-1,1),show=False, line_color=(0.3,0.5,0.1)) p1.extend(p2) p1.extend(p3) p1.show()
В этом примере с помощью атрибута line_color мы задали цвет первого графика, который из-за опции show=False был создан невидимым. Объекты графиков p2 и p3 вначале также созданы только в памяти. Затем с помощью метода p1.extend() они добавлены на первый график. Инструкция p1.show() рисует графики всех кривых.
Графические функции SymPy используют библиотеку matplotlib, поэтому управлять многими свойствами графиков можно, используя функции этой библиотеки. Например, фон окна или его заголовок можно задать, используя методы объекта Figure. from sympy import * from sympy.plotting import plot

202 x = symbols('x') y = x/(1 + x**2 ) plot(y, (x, -3, 3), ylim=(-1,1), line_color='firebrick') fig=plt.gcf() fig.set_facecolor('white') fig.text(0.6,0.3,'Graphics',fontsize=24)
В одной функции plot() можно строить несколько графиков. Для каждой кривой нужно задавать цвет отдельно, обращаясь к ним по индексу. x = symbols('x') f1 = x**2 f2 = -x**2 str=latex(S('x**2 , -x**2 ',evaluate=False)) p = plot((f1, (x, -1, 0)), (f2, (x, 0, 1)), title='$'+str+'$', show=False) p[0].line_color = 'blue' p[1].line_color = 'red' p.show()
Если диапазон изменения переменной одинаковый для всех функций, то график нескольких кривых можно построить проще. plot(x, x**2, x**3, (x, -1, 1))
Можно принудительно задать точки, по которым будет строиться график. Для этого опцией adaptive=False надо отключить режим автоматического выбора точек на отрезке, и опцией nb_of_points=количество задать желаемое количество точек. x = symbols('x') plot(sin(x),(x,-3.5,3.5), adaptive=False, nb_of_points=10) fig=plt.gcf() fig.set_facecolor('white')
График кривых, задаваемых параметрическими уравнениями x=x(t), y=y(t), строится с помощью функции plot_parametric(x(t),y(t),(t,tmin,tmax)[,...]).
Первые два аргумента представляют выражения x(t),y(t), которые определяют координаты x и y как функцию параметра t. Третий аргумент определяет диапазон изменения параметра t. from sympy.plotting import plot_parametric t = symbols('t') plot_parametric(2*t*sin(t), t*cos(t),
(t, 0, 50), line_color='r') fig=plt.gcf() ax=fig.gca() ax.axis('equal')
Можно строить несколько кривых с общим диапазоном изменения параметра.
Атрибут line_color, задающий цвет, должен быть функцией, возвращающей

203 числовое значение. Если функция принимает один аргумент, то он рассматривается как параметр кривой. Если функция цвета принимает два параметра, то они рассматриваются как пространственные координаты точек. p=plot_parametric((cos(t), sin(t)),
(t*cos(t)/3, t*sin(t)/3),
(t,0,2*pi),ylim=( -2,1.5), margin=0.2,show=False) p[0].line_color=lambda t: sin(t) p[1].line_color=lambda x,y: x p.show()
Для каждой кривой на графике можно задать свой диапазон изменения параметра. pp=
plot_parametric((cos(t), sin(t),(t,0,2*pi)), \
(t*cos(t)/10, t*sin(t)/10,(t,0,50)), \ ylim=(-5,5),margin=0.2)
Для построения графиков функций 2 – х переменных предназначена функция plot3d(expr,(x,x min
,x,x max
),(y,y min
,y max
)[,...]). from sympy import * from sympy.plotting import plot3d var('x y') plot3d((exp(-(x**2+y**2))),(x,-3,3),(y,-3,3))
# следующий график слева
Атрибуту surface_color можно присвоить функцию, которая должна возвращать вещественное число, и которая будет представлять цвет точек поверхности. g = plotting.plot3d(sin(x/2)*cos(y/2), (x, -6, 6), (y, -6, 6), show=False) g[0].surface_color = lambda x, y: sin(x) g.show()
# следующий график справа
Чтобы атрибут surface_color подействовал, сначала должен быть сознан невидимый объект поверхности, потом для него задается значение атрибута цвета и, только потом, поверхность должна быть отображена.
На одном графике можно строить несколько поверхностей, имеющих общие диапазоны по x и y. plotting.plot3d(-x**2-y**2,Abs(x-y)+Abs(x+y),(x,-1,1),(y,-1,1))
Этот график показан на следующем рисунке слева

204
Можно задавать диапазоны изменения независимых переменных для каждой функции. p=plot3d((-Abs(x)-Abs(y),(x, -1.5,1.5),(y,-1.5,1.5)),
(Abs(x-y)+Abs(x+y),(x,-1,1),(y,-1,1)), show=False) p[0].surface_color = lambda x, y: x**2 -y**2 p[1].surface_color = lambda x, y: Abs(x -y)+Abs(x+y) p.show()
# предыдущий график справа
У функции plot3d() есть опции nb_of_points_x, nb_of_points_y, которые задают количество точек разбиения области изменения независимых переменных x и y. Имеется также опция surface_color, которая должна быть функцией двух переменных. f=lambda x,y:Abs(3-x**2-2*y**2) p = plotting.plot3d(f(x,y), (x, -1.6, 1.6), (y, -1.6, 1.6), \ nb_of_points_x=60,nb_of_points_y=60, \ surface_color = lambda x, y: y**2 -x**2) p.show()
Функция plot3d_parametric_line() строит график пространственной кривой, заданной параметрически. В следующем примере строится график одной кривой. from sympy.plotting import plot3d_parametric _line u = symbols('u') p=plot3d_parametric_line(cos(u),sin(u),u,(u,0,20), line_color=lambda x, y, z: z / 10) p=plot3d_parametric_line(cos(u),sin(u),u,(u,0,20),show=False) p[0].line_color = lambda x, y, z: z / 10 p.show()
Здесь мы использовали опцию line_color, которая должна быть функцией одной, двух или трех переменных.
Можно строить графики нескольких кривых. p = plot3d_parametric_line((t*cos(t), t*sin(t), t, (t, 0, 15)),

205
(1.5*t*cos(t), 1.5*t*sin(t), t, (t, 0, 15)),
(2*t*cos(t), 2*t*sin(t), t, (t, 0, 15)), show=False)
p[0].line_color = lambda t: t
# t – параметр кривой p[1].line_color = lambda x, y: x*y
# x,y пространственные координаты p[2].line_color = lambda x, y, z: x*y*z
# все пространственные координаты p.show()
У функции plot3d_parametric_line() имеется опция nb_of_points, задающая количество точек на кривой.
Функция plot3d_parametric_surface() строит график поверхности, заданной параметрическими уравнениями. from sympy.plotting import plot3d_parametric_surface u, v = symbols('u v') plot3d_parametric_surface(cos(u)*v,sin(u)*v,u,(u,0,10),(v, -2,2))
У функции plot3d_parametric_surface() имеются опции nb_of_points_u, nb_of_points_v, назначение которых понятно из их названия. Использование этих опций для поверхностей с ребрами позволяет эти ребра правильно отображать. В следующем примере мы строим треугольную пирамиду по ее параметрическим уравнениям и корректное задание значений nb_of_points_u, nb_of_points_v позволяет улучшить изображение поверхности. Имеется также опция (и атрибут) surface_color , которая должна принимать ссылку на функцию. u, v = symbols('u v')
X=(2*Abs(v)-3*Abs(v-1)+Abs(v-3))*(-4+3*Abs(u)-3*Abs(u-1)-
3*Abs(u-2)+3*Abs(u-3))/2
Y=-(2*Abs(v)-3*Abs(v-1)+Abs(v-3) )*\
(3*Abs(u-1)-3*Abs(u-2)+Abs(u-3)-Abs(u));
Z=4*(2+Abs(v-1)-Abs(v-3)); plot3d_parametric_surface(X,Y,Z,(u,0,3),(v,0,3), nb_of_points_u=31,nb_of_points_v=31)
# следующ. рисунок слева

206 plot3d_parametric_surface(X,Y,Z,(u,0,3),(v,0,3), \ nb_of_points_u=31,nb_of_points_v=31, \ surface_color = lambda x, y, z: x*y*z)
# следующ. рисунок справа
Функция plot_implicit()строит кривые по их неявным уравнениям, или рисует залитые области, заданные неравенствами. Использование функции поясним на примерах.
В следующем примере мы рисуем кривую по ее неявному уравнению
5 2
2


y
x
. Напомним, что уравнения в SymPy записываются с использованием функции Eq(). Например, последнее уравнение записывается в форме
Eq(x**2+y**2, 5). x, y = symbols('x y') plot_implicit(Eq(x**2 + y**2, 5)) fig=plt.gcf() ax=fig.gca() ax.axis('equal') ax.set_xlim(-3,3) ax.set_ylim(-3,3)
Можно задать диапазон изменения независимых переменных. В следующем примере мы строим квадрат по его неявному уравнению. Иногда отключение адаптивной сетки опцией adaptive=False улучшает изображение.
W=2-x**2-y**2-sqrt((1-x**2)**2+(1-y**2)**2) plot_implicit(W ,(x, -1.2,1.2),(y, -1.2,1.2), adaptive=False) fig=plt.gcf() ax=fig.gca() ax.axis('equal')
Опцией points=количество можно задать количество точек в области изменения переменных x и y. Опция depth задает глубину рекурсии при поиске точек неявно заданной кривой. Эту опцию имеет смысл использовать в паре с опцией adaptive=False.
Для построения областей в качестве первого аргумента функции plot_implicit() следует использовать неравенства. from sympy.plotting import plot_implicit

207 plot_implicit(x**2+y**2<1) fig=plt.gcf() fig.set_facecolor('white') ax=fig.gca() ax.axis('equal')
В этом примере заметно влияние опции depth. В предыдущем примере добавьте опцию depth=2 в функцию plot_implicit() и граница области (круга) станет более гладкой. plot_implicit(x**2+y**2<1, depth=2)
Опциями adaptive=True/False и points=количество можно управлять густотой сетки, используемой в алгоритме построения кривой или области. А опция line_color используется для задания цвета области. plot_implicit(x**2+y**2<1,adaptive=False, points=100, line_color='
с') fig=plt.gcf() ax=fig.gca() ax.axis('equal') ax.set_xlim(-2,2) ax.set_ylim(-2,2)
Для построения более сложных областей следует использовать булевы операции между неравенствами. В следующих примерах мы демонстрируем применение функций And(), Or() и Not(). Фактически мы здесь строим диаграммы Эйлера для соответствующих операций. var('x y U V')
U=x**2+y**2<1
V=(x-1)**2+y**2<1 plot_implicit(And(U, V),(x, -1, 2), (y, -1, 1)) var('x y U V')
U=x**2+y**2<1
V=(x-1)**2+y**2<1 plot_implicit(Or(U, V),(x, -1, 2), (y, -1, 1)) var('x y U V')
U=x**2+y**2<1
V=(x-1)**2+y**2<1 plot_implicit(And(U,Not(V)),(x, -1, 2), (y, -1, 1))
Упомянем еще об одной «экзотической» функции textplot(expr,x min
,x max
), которая имитирует построение графика символьного выражения expr на отрезке [x min
,x max
] в текстовом режиме. from sympy import * var('x')
textplot(E**-x**2,-3,3)

208