Математическая библиотека Python SymPy

SymPy — это библиотека Python для выполнения символьных вычислений. Это система компьютерной алгебры, которая может выступать как отдельное приложение, так и в качестве библиотеки для других приложений. Поработать с ней онлайн можно на https://live.sympy.org/. Поскольку это чистая библиотека Python, ее можно использовать даже в интерактивном режиме.

В SymPy есть разные функции, которые применяются в сфере символьных вычислений, математического анализа, алгебры, дискретной математики, квантовой физики и так далее. SymPy может представлять результат в разных форматах: LaTeX, MathML и так далее. Распространяется библиотека по лицензии New BSD. Первыми эту библиотеку выпустили разработчики Ondřej Čertík и Aaron Meurer в 2007 году. Текущая актуальная версия библиотеки — 1.6.2.

Вот где применяется SymPy:

  • Многочлены
  • Математический анализ
  • Дискретная математика
  • Матрицы
  • Геометрия
  • Построение графиков
  • Физика
  • Статистика
  • Комбинаторика

Установка SymPy

Для работы SymPy требуется одна важная библиотека под названием mpmath. Она используется для вещественной и комплексной арифметики с числами с плавающей точкой произвольной точности. Однако pip установит ее автоматически при загрузке самой SymPy:

pip install sympy

Такие дистрибутивы, как Anaconda, Enthough, Canopy и другие, заранее включают SymPy. Чтобы убедиться в этом, достаточно ввести в интерактивном режиме команду:

>>> import sympy
>>> sympy.__version__
'1.6.2'

Исходный код можно найти на GitHub.

Символьные вычисления в SymPy

Символьные вычисления — это разработка алгоритмов для управления математическими выражениями и другими объектами. Такие вычисления объединяют математику и компьютерные науки для решения математических выражений с помощью математических символов.

Система компьютерной алгебры же, такая как SymPy, оценивает алгебраические выражения с помощью тех же символов, которые используются в традиционных ручных методах. Например, квадратный корень числа с помощью модуля math в Python вычисляется вот так:

import math 

print(math.sqrt(25), math.sqrt(7))

Вывод следующий:

5.0 2.6457513110645907

Как можно увидеть, квадратный корень числа 7 вычисляется приблизительно. Но в SymPy квадратные корни чисел, которые не являются идеальными квадратами, просто не вычисляются:

Вот каким будет вывод этого кода: sqrt(7).

Это можно упростить и показать результат выражения символически таким вот образом:

>>> import math
>>> print(math.sqrt(12))
3.4641016151377544
>>> import sympy
>>> print(sympy.sqrt(12))
2*sqrt(3)

В случае с модулем math вернется число, а вот в SymPy — формула.

Для рендеринга математических символов в формате LaTeX код SymPy, используйте Jupyter notebook:

from sympy import *
x = Symbol('x')
expr = integrate(x**x, x)
expr

Если выполнить эту команду в IDLE, то получится следующий результат:

Integral(x**x,x)

А в Jupyter:

Символьные вычисления в SymPy

Квадратный корень неидеального корня также может быть представлен в формате LaTeX с помощью привычных символов:

Квадратный корень может быть представлен в формате LaTeX

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

В пакете SymPy есть разные модули, которые помогают строить графики, выводить результат (LaTeX), заниматься физикой, статистикой, комбинаторикой, числовой теорией, геометрией, логикой и так далее.

Числа

Основной модуль в SymPy включает класс Number, представляющий атомарные числа. У него есть пара подклассов: Float и Rational. В Rational также входит Integer.

Класс Float

Float представляет числа с плавающей точкой произвольной точности:

>>> from sympy import Float 
>>> Float(6.32)
6.32

SymPy может конвертировать целое число или строку в число с плавающей точкой:

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

Представить число дробью можно с помощью объекта класса Rational, где знаменатель — не 0:

Математическая библиотека Python SymPy

Если число с плавающей точкой передать в конструктор Rational(), то он вернет дробь:

Rational вернет дробь

Для упрощения можно указать ограничение знаменателя:

Выведется дробь 1/5 вместо 3602879701896397/18014398509481984.

Если же в конструктор передать строку, то вернется рациональное число произвольной точности:

Математическая библиотека Python SymPy

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

>>> a=Rational(3, 5) 
>>> print(a)
3/5
>>> print("числитель:{}, знаменатель:{}".format(a.p, a.q))
числитель:3, знаменатель:5

Класс Integer

Класс Integer в SymPy представляет целое число любого размера. Конструктор принимает рациональные и числа с плавающей точкой. В результате он откидывает дробную часть:

>>> Integer(10)
10
>>> Integer(3.4)
3
>>> Integer(2/7)
0

Также есть класс RealNumber, который является алиасом для Float. В SymPy есть классы-одиночки Zero и One, доступные через S.Zero и S.One соответственно.

Другие числовые объекты-одиночки — Half, NaN, Infinity и ImaginaryUnit.

>>> from sympy import S 
>>> print(S.Half)
1/2
>>> print(S.NaN)
nan

Бесконечность представлена в виде объекта-символа oo или как S.Infinity:

Математическая библиотека Python SymPy

ImaginaryUnit можно импортировать как символ I, а получить к нему доступ — через S.ImaginaryUnit.

ImaginaryUnit можно импортировать как символ I

Символы

Symbol — самый важный класс в библиотеке SymPy. Как уже упоминалось ранее, символьные вычисления выполняются с помощью символов. И переменные SymPy являются объектами класса Symbol.

Аргумент функции Symbol() — это строка, содержащая символ, который можно присвоить переменной.

>>> from sympy import Symbol 
>>> x = Symbol('x') 
>>> y = Symbol('y') 
>>> expr = x**2 + y**2 
>>> expr

Код выше является эквивалентом этого выражения:

Математическая библиотека Python SymPy

Символ может включать больше одной буквы:

from sympy import Symbol
s = Symbol('side') 
s**3

Также в SymPy есть функция Symbols(), с помощью которой можно определить несколько символов за раз. Строка содержит названия переменных, разделенные запятыми или пробелами.

from sympy import symbols
x, y, z = symbols("x, y, z")

В модуле abc можно найти элементы латинского и греческого алфавитов в виде символов. Таким образом вместо создания экземпляра Symbol можно использовать метод:

Однако C, O, S, I, N, E и Q являются заранее определенными символами. Также символы с более чем одной буквы не определены в abc. Для них нужно использовать объект Symbol. Модуль abs определяет специальные имена, которые могут обнаружить определения в пространстве имен SymPy по умолчанию. сlash1 содержит однобуквенные символы, а clash2 — целые слова.

>>> from sympy.abc import _clash1, _clash2 
>>> _clash1
{'C': C,'O': O,'Q': Q,'N': N,'I': I,'E': E,'S': S}
>>> _clash2
{'beta': beta,'zeta': zeta,'gamma': gamma,'pi': pi}

Индексированные символы (последовательность слов с цифрами) можно определить с помощью синтаксиса, напоминающего функцию range(). Диапазоны обозначаются двоеточием. Тип диапазона определяется символом справа от двоеточия. Если это цифра, то все смежные цифры слева воспринимаются как неотрицательное начальное значение.

Смежные цифры справа берутся на 1 больше конечного значения.

>>> from sympy import symbols 
>>> symbols('a:5')
(a0,a1,a2,a3,a4)
>>> symbols('mark(1:4)')
(mark1,mark2,mark3)

Подстановка параметров

Одна из базовых операций в математических выражениях — подстановка. Функция subs() заменяет все случаи первого параметра на второй.

>>> from sympy.abc import x, a 
>>> expr = sin(x) * sin(x) + cos(x) * cos(x) 
>>> expr

Этот код даст вывод, эквивалентный такому выражению.

Подстановка параметров

А кодом expr.subs(x,a) мы получим туже формулу, но с a вместо x.

Эта функция полезна, когда требуется вычислить определенное выражение. Например, нужно посчитать значения выражения, заменив a на 5:

Математическая библиотека Python SymPy
>>> from sympy.abc import x 
>>> from sympy import sin, pi 
>>> expr = sin(x) 
>>> expr1 = expr.subs(x, pi) 
>>> expr1
0

Также функция используется для замены подвыражения другим подвыражением. В следующем примере b заменяется на a+b.

>>> from sympy.abc import a, b 
>>> expr = (a + b)**2 
>>> expr1 = expr.subs(b, a + b) 
>>> expr1

Это дает такой вывод:

замена подвыражения другим подвыражением

Функция simplify()

Функция simplify() используется для преобразования любого произвольного выражения, чтобы его можно было использовать как выражение SymPy. Обычные объекты Python, такие как целые числа, конвертируются в SymPy.Integer и так далее. Строки также конвертируются в выражения SymPy:

>>> expr = "x**2 + 3*x +  2" 
>>> expr1 = sympify(expr)
>>> expr1.subs(x, 2)
12

Любой объект Python можно конвертировать в объект SymPy. Однако учитывая то, что при преобразовании используется функция eval(), не стоит использовать некорректные выражения, иначе возникнет ошибка SimplifyError.

>>> sympify("x***2")
...
SympifyError: Sympify of expression 'could not parse 'x***2'' failed, because of exception being raised:
SyntaxError: invalid syntax (<string>, line 1)

Функция simplify() принимает следующий аргумент: strict=False. Если установить True, то преобразованы будут только те типы, для которых определено явное преобразование. В противном случае также возникнет ошибка SimplifyError. Если же поставить False, то арифметические выражения и операторы будут конвертированы в их эквиваленты SumPy без вычисления выражения.

Математическая библиотека Python SymPy

Функция evalf()

Функция вычисляет данное числовое выражение с точностью до 100 цифр после плавающей точки. Она также принимает параметр subs, как объект словаря с числовыми значениями для символов. Например такое выражение:

from sympy.abc import r 
expr = pi * r**2 
expr

Даст такой результат: 𝜋𝑟2

Вычислим выражение с помощью evalf() и заменим r на 5:

>>> expr.evalf(subs={r: 5})
78.5398163397448

По умолчанию точность после плавающей точки — 15, но это значение можно перезаписать до 100. Следующее выражение вычисляет, используя вплоть до 20 цифр точности:

>>> expr = a / b 
>>> expr.evalf(20, subs={a: 100, b: 3})
33.333333333333333333

Функция lambdify()

Функция lambdify() переводит выражения SymPy в функции Python. Если выражение, которое нужно вычислить, затрагивает диапазон значений, то функция evalf() становится неэффективной. Функция lambdify действует как лямбда-функция с тем исключением, что она конвертирует SymPy в имена данной числовой библиотеки, обычно NumPy. По умолчанию же она реализована на основе стандартной библиотеки math.

>>> expr =1 / sin(x) 
>>> f = lambdify(x, expr) 
>>> f(3.14)
627.8831939138764

У выражения может быть больше одной переменной. В таком случае первым аргументом функции является список переменных, а после него — само выражение:

>>> expr = a**2 + b**2 
>>> f = lambdify([a, b], expr) 
>>> f(2, 3)
13

Но чтобы использовать numpy в качестве основной библиотеки, ее нужно передать в качестве аргумента функции lambdify().

В этой функции использовались два массива numpy: a и b. В случае с ними выполнение гораздо быстрее:

>>> import numpy 
>>> l1 = numpy.arange(1, 6) 
>>> l2 = numpy.arange(6, 11) 
>>> f(l1, l2)
array([ 37,  53,  73,  97, 125], dtype=int32)

Логические выражения

Булевы функции расположены в модуле sympy.basic.booleanarg. Их можно создать и с помощью стандартных операторов Python: & (And), | (Or), ~ (Not), а также >> и <<. Булевы выражения наследуются от класса Basic.

BooleanTrue.
Эта функция является эквивалентом True из Python. Она возвращает объект-одиночку, доступ к которому можно получить и с помощью S.true.

>>> from sympy import *
>>> x = sympify(true)
>>> x, S.true
(True, True)

BooleanFalse.
А эта функция является эквивалентом False. Ее можно достать с помощью S.False.

>>> from sympy import * 
>>> x = sympify(false) 
>>> x, S.false
(False,False)

And.
Функция логического AND оценивает два аргумента и возвращает False, если хотя бы один из них является False. Эта функция заменяет оператор &.

>>> from sympy import * 
>>> from sympy.logic.boolalg import And 
>>> x, y = symbols('x y') 
>>> x = True 
>>> y = True 
>>> And(x, y), x & y

Or.
Оценивает два выражения и возвращает True, если хотя бы одно из них является True. Это же поведение можно получить с помощью оператора |.

>>> from sympy import * 
>>> from sympy.logic.boolalg import Or 
>>> x, y = symbols('x y') 
>>> x = True 
>>> y = False 
>>> Or(x, x|y)

Not.
Результат этой функции — отрицание булево аргумента. True, если аргумент является False, и False в противном случае. В Python за это отвечает оператор ~. Пример:

>>> from sympy import * 
>>> from sympy.logic.boolalg import Or,And,Not 
>>> x, y = symbols('x y') 
>>> x = True 
>>> y = False 
>>> Not(x), Not(y)
(False, True)

Xor.
Логический XOR (исключающий OR) возвращает True, если нечетное количество аргументов равняется True, а остальные — False. False же вернется в том случае, если четное количество аргументов True, а остальные — False. То же поведение работает в случае оператора ^.

>>> from sympy import * 
>>> from sympy.logic.boolalg import Xor 
>>> x, y = symbols('x y') 
>>> x = True 
>>> y = False
>>> Xor(x, y)
True

В предыдущем примере один(нечетное число) аргумент является True, поэтому Xor вернет True. Если же количество истинных аргументов будет четным, результатом будет False, как показано дальше.

Nand.
Выполняет логическую операцию NAND. Оценивает аргументы и возвращает True, если хотя бы один из них равен False, и False — если они истинные.

>>> from sympy.logic.boolalg import Nand
>>> a, b, c = (True, False, True) 
>>> Nand(a, c), Nand(a, b)
(False, True)

Nor.
Выполняет логическую операцию NOR. Оценивает аргументы и возвращает False, если один из них True, или же True, если все — False.

>>> from sympy.logic.boolalg import Nor 
>>> a, b = False, True 
>>> Nor(a), Nor(a, b)
(True, False)

Хотя SymPy и предлагает операторы ^ для Xor, ~ для Not, | для Or и & для And ради удобства, в Python они используются в качестве побитовых. Поэтому если операнды будут целыми числами, результаты будут отличаться.

Equivalent.
Эта функция возвращает отношение эквивалентности. Equivalent(A, B) будет равно True тогда и только тогда, когда A и B оба будут True или False. Функция вернет True, если все аргументы являются логически эквивалентными. В противном случае — False.

>>> from sympy.logic.boolalg import Equivalent 
>>> a, b = True, False
>>> Equivalent(a, b), Equivalent(a, True)
( False, True)

Запросы

Модуль assumptions в SymPy включает инструменты для получения информации о выражениях. Для этого используется функция ask().

Следующие свойства предоставляют полезную информацию о выражении:

sympy.assumptions.ask(выражение)

algebraic(x)
Чтобы быть алгебраическим, число должно быть корнем ненулевого полиномиального уравнения с рациональными коэффициентами. √2, потому что √2 — это решение x2 − 2 = 0. Следовательно, это выражения является алгебраическим.

complex(x)
Предикат комплексного числа. Является истиной тогда и только тогда, когда x принадлежит множеству комплексных чисел.

composite(x)
Предикат составного числа, возвращаемый ask(Q.composite(x)) является истиной тогда и только тогда, когда x — это положительное число, имеющее как минимум один положительный делитель, кроме 1 и самого числа.

even, odd
ask() возвращает True, если x находится в множестве четных и нечетных чисел соответственно.

imaginary
Свойство представляет предикат мнимого числа. Является истиной, если x можно записать как действительное число, умноженное на мнимую единицу.

integer
Это свойство, возвращаемое Q.integer(x), будет истинным только в том случае, если x принадлежит множеству четных чисел.

rational, irrational
Q.irrational(x) истинно тогда и только тогда, когда x — это любое реальное число, которое нельзя представить как отношение целых чисел. Например, pi — это иррациональное число.

positive, negative
Предикаты для проверки того, является ли число положительным или отрицательным.

zero, nonzero
Предикат для проверки того, является ли число нулем или нет.

>>> from sympy import * 
>>> x = Symbol('x') 
>>> x = 10 
>>> ask(Q.algebraic(pi))
False
>>> ask(Q.complex(5-4*I)), ask(Q.complex(100))
(True, True)
>>> x, y = symbols("x y") 
>>> x, y = 5, 10 
>>> ask(Q.composite(x)), ask(Q.composite(y))
(False, True)
>>> ask(Q.even(x)), ask(Q.even(y))
(True, None)
>>> ask(Q.imaginary(x)), ask(Q.imaginary(y))
(True, False)
>>> ask(Q.even(x)), ask(Q.even(y)), ask(Q.odd(x)), ask(Q.odd(y))
(True, True, False, False)
>>> ask(Q.positive(x)), ask(Q.negative(y)), ask(Q.positive(x)), ask(Q.negative(y))
(True, True)
>>> ask(Q.rational(pi)), ask(Q.irrational(S(2)/3))
(False, False)
>>> ask(Q.zero(oo)), ask(Q.nonzero(I))
(False, False)

Функции упрощения

SymPy умеет упрощать математические выражения. Для этого есть множество функций. Основная называется simplify(), и ее основная задача — представить выражение в максимально простом виде.

simplify

Это функция объявлена в модуле sympy.simplify. Она пытается применить методы интеллектуальной эвристики, чтобы сделать входящее выражение «проще». Следующий код упрощает такое выражение: sin^2(x)+cos^2(x)

>>> x = Symbol('x')
>>> expr = sin(x)**2 + cos(x)**2 
>>> simplify(expr)
1

expand

Одна из самых распространенных функций упрощения в SymPy. Она используется для разложения полиномиальных выражений. Например:

>>> a, b = symbols('a b') 
>>> expand((a+b)**2)

А тут вывод следующий: 𝑎2+2𝑎𝑏+𝑏2.

Вывод: 𝑎2−𝑏2.

Функция expand() делает выражение больше, а не меньше. Обычно это так и работает, но часто получается так, что выражение становится меньше после использования функции:

factor

Эта функция берет многочлен и раскладывает его на неприводимые множители по рациональным числам.

>>> x, y, z = symbols('x y z') 
>>> expr = (x**2*z + 4*x*y*z + 4*y**2*z) 
>>> factor(expr)

Вывод: 𝑧(𝑥+2𝑦)2.

Функция factor() — это противоположность expand(). Каждый делитель, возвращаемый factor(), будет несокращаемым. Функция factor_list() предоставляет более структурированный вывод:

>>> expr=(x**2*z + 4*x*y*z + 4*y**2*z) 
>>> factor_list(expr)
(1, [(z, 1), (x + 2*y, 2)])

collect

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

>>> expr = x*y + x - 3 + 2*x**2 - z*x**2 + x**3 
>>> expr

Вывод: 𝑥3−𝑥2𝑧+2𝑥2+𝑥𝑦+𝑥−3.

Результат работы collect():

>>> expr = y**2*x + 4*x*y*z + 4*y**2*z + y**3 + 2*x*y 
>>> collect(expr, y)

Вывод: 𝑦3+𝑦2(𝑥+4𝑧)+𝑦(4𝑥𝑧+2𝑥).

cancel

Эта функция берет любую рациональную функцию и приводит ее в каноническую форму p/q, где p и q — это разложенные полиномы без общих множителей. Старшие коэффициенты p и q не имеют знаменателей, то есть, являются целыми числами.

>>> expr1=x**2+2*x+1 
>>> expr2=x+1 
>>> cancel(expr1/expr2)
x + 1

Еще несколько примеров:

функция cancel

trigsimp

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

>>> from sympy import trigsimp, sin, cos 
>>> from sympy.abc import x, y
>>> expr = 2*sin(x)**2 + 2*cos(x)**2 
>>> trigsimp(expr)
2

Функция trigsimp использует эвристику для применения наиболее подходящего тригонометрического тождества.

powersimp

Эта функция сокращает выражения, объединяя степени с аналогичными основаниями и значениями степеней.

Вывод: 𝑥𝑦𝑥𝑧𝑦𝑧.

Можно сделать так, чтоб powsimp() объединяла только основания или степени, указав combine='base' или combine='exp'. По умолчанию это значение равно combine='all'. Также можно задать параметр force. Если он будет равен True, то основания объединятся без проверок.

>>> powsimp(expr, combine='base', force=True)

Вывод: 𝑥𝑦(𝑥𝑦)𝑧.

combsimp

Комбинаторные выражения, включающие факториал и биномы, можно упростить с помощью функции combsimp(). В SymPy есть функция factorial().

Комбинаторные выражения, включающие факториал и биномы

Для упрощения предыдущего комбинаторного выражения эта функция используется следующим образом.

binomial(x, y) — это количество способов, какими можно выбрать элементы y из множества элементов x. Его же можно записать и как xCy.

упрощение комбинаторного выражения

logcombine

Эта функция принимает логарифмы и объединяет их с помощью следующих правил:

  • log(x) + log(y) == log(x*y) — оба положительные.
  • a*log(x) == log(x**a) если x является положительным и вещественным.
>>> logcombine(a*log(x) + log(y) - log(z))
𝑎log(𝑥)+log(𝑦)−log(𝑧)

Если здесь задать значение параметра force равным True, то указанные выше предположения будут считаться выполненными, если нет предположений о величине.

функция принимает логарифмы и объединяет их

Производные

Производная функции — это ее скорость изменения относительно одной из переменных. Это эквивалентно нахождению наклона касательной к функции в точке. Найти дифференцирование математических выражений в форме переменных можно с помощью функции diff() из SymPy.

>>> from sympy import diff, sin, exp 
>>> from sympy.abc import x, y 
>>> expr = x*sin(x*x) + 1
>>> expr

Вывод: 𝑥sin(𝑥2)+1.

Чтобы получить несколько производных, нужно передать переменную столько раз, сколько нужно выполнить дифференцирование. Или же можно просто указать это количество с помощью числа.

Также можно вызвать метод diff() выражения. Он работает по аналогии с функцией.

Вывод: 2𝑥2cos(𝑥2)+sin(𝑥2).

Неоцененная производная создается с помощью класса Derivative. У него такой же синтаксис, как и функции diff(). Для оценки же достаточно использовать метод doit.

Производная функции

Интеграция

SymPy включает и модуль интегралов. В нем есть методы для вычисления определенных и неопределенных интегралов выражений. Метод integrate() используется для вычисления обоих интегралов. Для вычисления неопределенного или примитивного интеграла просто передайте переменную после выражения.

Для вычисления определенного интеграла, передайте аргументы следующим образом:

модуль интегралов

Пример определенного интеграла:

Пример определенного интеграла

С помощью объекта Integral можно создать неоцененный интеграл. Он оценивается с помощью метода doit().

неоцененный интеграл

Трансформации интегралов

SymPy поддерживает разные виды трансформаций интегралов:

  • laplace_tranfsorm.
  • fourier_transform.
  • sine_tranfsorm.
  • cosine_transform.
  • hankel_transform.

Эти функции определены в модуле sympy.integrals.transforms. Следующие примеры вычисляют преобразования Фурье и Лапласа соответственно:

преобразования Фурье и Лапласа
>>> from sympy.integrals import laplace_transform 
>>> from sympy.abc import t, s, a 
>>> laplace_transform(t**a, t, s)
(s**(-a)*gamma(a + 1)/s, 0, re(a) > -1)

Матрицы

В математике матрица — это двумерный массив чисел, символов или выражений. Теория манипуляций матрицами связана с выполнением арифметических операций над матричными объектами при соблюдении определенных правил.

Линейная трансформация — одно из важнейших применений матрицы. Она часто используется в разных научных областях, особенно связанных с физикой. В SymPy есть модуль matrices, который работает с матрицами. В нем есть класс Matrix для представления матрицы.

Примечание: для выполнения кода в этом разделе нужно сперва импортировать модуль matrices следующим образом.

>>> from sympy.matrices import Matrix 
>>> m=Matrix([[1, 2, 3], [2, 3, 1]]) 
>>> m
⎡1  2  3⎤
⎣2  3  1⎦

Матрица — это изменяемый объект. Также в модуле есть класс ImmutableMatrix для получения неизменяемой матрицы.

Базовое взаимодействие

Свойство shape возвращает размер матрицы.

Методы row() и col() возвращают колонку или строку соответствующего числа.

>>> m.row(0)
[1  2  3]
>>> m.col(1)
⎡2⎤
⎣3⎦

Оператор slice из Python можно использовать для получения одного или большего количества элементов строки или колонки.

У класса Matrix также есть методы row_del() и col_del(), которые удаляют указанные строку/колонку из выбранной матрицы.

>>> m.row(1)[1:3]
[3, 1]
>>> m.col_del(1) 
>>> m
⎡1  3⎤
⎣2  1⎦

По аналогии row_insert() и col_insert() добавляют строки и колонки в обозначенные индексы:

>>> m1 = Matrix([[10, 30]]) 
>>> m = m.row_insert(0, m1)
>>> m
⎡10  30⎤
⎢ 1  3 ⎥
⎣ 2  1 ⎦

Арифметические операции

Привычные операторы +, — и * используются для сложения, умножения и деления.

>>> M1 = Matrix([[3, 0], [1, 6]]) 
>>> M2 = Matrix([[4, 5], [6, 4]]) 
>>> M1 + M2
⎡7     5 ⎤
⎣7    10 ⎦

Умножение матрицы возможно лишь в том случае, если количество колонок первой матрицы соответствует количеству колонок второй. Результат будет иметь такое же количество строк, как у первой матрицы и столько же колонок, сколько есть во второй.

Для вычисления определителя матрицы используется метод det(). Определитель — это скалярное значение, которое может быть вычислено из элементов квадратной матрицы.

>>> M = Matrix([[4, 5], [6, 4]])
>>> M.det()
-14

Конструкторы матрицы

SymPy предоставляет множество специальных типов классов матриц. Например, Identity, матрица из единиц, нолей и так далее. Эти классы называются eye, zeroes и ones соответственно. Identity — это квадратная матрица, элементы которой по диагонали равны 1, а остальные — 0.

Конструкторы матрицы

В матрице diag элементы по диагонали инициализируются в соответствии с предоставленными аргументами.

>>> from sympy.matrices import diag 
>>> diag(1, 3)
⎡1  0 ⎤
⎣0  3 ⎦

Все элементы в матрице zero инициализируются как нули.

>>> from sympy.matrices import zeros 
>>> zeros(2, 3)
⎡0  0  0⎤
⎣0  0  0⎦

По аналогии в матрице ones элементы равны 1:

>>> from sympy.matrices import zeros 
>>> ones(2, 3)
⎡1  1  1⎤
⎣1  1  1⎦

Класс Function

В пакете SymPy есть класс Function, определенный в модуле sympy.core.function. Это базовый класс для всех математических функций, а также конструктор для неопределенных классов.

Следующие категории функций наследуются от класса Function:

  • Функции для комплексных чисел
  • Тригонометрические функции
  • Функции целого числа
  • Комбинаторные функции
  • Другие функции

Функции комплексных чисел

Набор этих функций определен в модуле sympy.functions.elementary.complexes.

re — Эта функция возвращает реальную часть выражения:

>>> from sympy import * 
>>> re(5+3*I)
5
>>> re(I)
0

im — Возвращает мнимую часть выражения:

sign — Эта функция возвращает сложный знак выражения..

Для реального выражения знак будет:

  • 1, если выражение положительное,
  • 0, если выражение равно нулю,
  • -1, если выражение отрицательное.

Если выражение мнимое, то знаки следующие:

  • l, если выражение положительное,
  • -l, если выражение отрицательное.
>>> sign(1.55), sign(-1), sign(S.Zero)
(1,-1,0)
>>> sign (-3*I), sign(I*2)
(-I, I)

Функция abs возвращает абсолютное значение комплексного числа. Оно определяется как расстояние между основанием (0, 0) и точкой на комплексной плоскости. Эта функция является расширением встроенной функции abs() и принимает символьные значения.

Например, Abs(2+3*I), вернет √13.

conjugate — Функция возвращает сопряжение комплексного числа. Для поиска меняется знак мнимой части.

Тригонометрические функции

В SymPy есть определения всех тригонометрических соотношений: синуса, косинуса, тангенса и так далее. Также есть обратные аналоги: asin, acos, atan и так далее. Функции вычисляют соответствующее значение данного угла в радианах.

>>> sin(pi/2), cos(pi/4), tan(pi/6)
(1, sqrt(2)/2, sqrt(3)/3)
>>> asin(1), acos(sqrt(2)/2), atan(sqrt(3)/3)
(pi/2, pi/4, pi/6)

Функции целого числа

Набор функций для работы с целым числом.

Одномерная функция ceiling, возвращающая самое маленькое целое число, которое не меньше аргумента. В случае с комплексными числами округление до большего целого для целой и мнимой части происходит отдельно.

>>> ceiling(pi), ceiling(Rational(20, 3)), ceiling(2.6+3.3*I)
(4, 7, 3 + 4*I)

floor — Возвращает самое большое число, которое не больше аргумента. В случае с комплексными числами округление до меньшего целого для целой и мнимой части происходит отдельно.

>>> floor(pi), floor(Rational(100, 6)), floor(6.3-5.9*I)
(3, 16, 6 - 6*I)

frac — Функция представляет долю x.

>>> frac(3.99), frac(10)
(0.990000000000000, 0)

Комбинаторные функции

Комбинаторика — это раздел математики, в котором рассматриваются выбор, расположение и работа в конечной и дискретной системах.

factorial — Факториал очень важен в комбинаторике. Он обозначает число способов, которыми могут быть представлены объекты.

Кватернион

В математика числовая система кватернион расширяет комплексные числа. Каждый объект включает 4 скалярные переменные и 4 измерения: одно реальное и три мнимых.

Кватернион можно представить в виде следующего уравнения: q = a + bi + cj + dk, где a, b, c и d — это реальные числа, а i, j и k — квартенионные единицы, так что i2 == j2 == k2 = ijk.

Класс Quaternion расположен в модуле sympy.algebras.quaternion.

>>> from sympy.algebras.quaternion import Quaternion 
>>> q = Quaternion(2, 3, 1, 4) 
>>> q
2+3𝑖+1𝑗+4𝑘

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

Кватернион

add()

Этот метод класса Quaternion позволяет сложить два объекта класса:

>>> q1=Quaternion(1,2,4) 
>>> q2=Quaternion(4,1) 
>>> q1.add(q2)
5+3𝑖+4𝑗+0𝑘

Также возможно добавить число или символ к объекту Quaternion.

>>> q1+2
3+2𝑖+4𝑗+0𝑘
>>> q1+x
(𝑥+1)+2𝑖+4𝑗+0𝑘

mul()

Этот метод выполняет умножение двух кватернионов.

>>> q1 = Quaternion(1, 2) 
>>> q2 = Quaternion(2, 4, 1) 
>>> q1.mul(q2)
(−6)+8𝑖+1𝑗+2𝑘

inverse()

Возвращает обратный кватернион.

inverse(-)Возвращает обратный кватернион

pow()

Возвращает степень кватерниона.

exp()

Вычисляет экспоненту кватерниона.

exp() Вычисляет экспоненту кватерниона

Уравнения

Поскольку символы = и == определены как символ присваивания и равенства в Python, их нельзя использовать для создания символьных уравнений. Для этого в SymPy есть функция Eq().

>>> x, y = symbols('x y') 
>>> Eq(x, y)
𝑥=𝑦

Поскольку x=y возможно только в случае x-y=0, уравнение выше можно записать как:

Модуль solver из SymPy предлагает функцию solveset():

solveset(equation,variable,domain)

Параметр domain по умолчанию равен S.Complexes. С помощью функции solveset() можно решить алгебраическое уравнение.

>>> solveset(Eq(x**2-9, 0), x)
{−3,3}
>>> solveset(Eq(x**2-3*x, -2), x)
{1,2}

Линейное уравнение

Для решения линейных уравнений нужно использовать функцию linsolve().

Например, уравнения могут быть такими:

  • x-y=4
  • x+1=1
Математическая библиотека Python SymPy

Функция linsolve() также может решать линейные уравнения в матричной форме:

>>> a, b = symbols('a b') 
>>> a = Matrix([[1, -1], [1, 1]]) 
>>> b = Matrix([4, 1]) 
>>> linsolve([a, b], y)

Вывод будет тот же.

Нелинейное уравнение

Для таких уравнений используется функция nonlinsolve(). Пример такого уравнения:

>>> a, b = symbols('a b') 
>>> nonlinsolve([a**2 + a, a - b], [a, b])
{(−1, −1),(0, 0)}

Дифференциальное уравнение

Для начала создайте функцию, передав cls=Function в функцию symbols. Для решения дифференциальных уравнений используйте dsolve.

>>> x = ymbol('x') 
>>> f = symbols('f', cls=Function) 
>>> f(x)
𝑓(𝑥)

Здесь f(x) — это невычисленная функция. Ее производная:

 f(x)  производная

Сначала создается объект Eq, соответствующий следующему дифференциальному уравнению.

Дифференциальное уравнение

Графики

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

pip install matplotlib

Функции для работы с графиками можно найти в модуле sympy.plotting:

  • plot — двухмерные линейные графики.
  • plot3d — трехмерные линейные графики.
  • plot_parametric — двухмерные параметрические графики.
  • plot3d_parametric — трехмерные параметрические графики.

Функция plot() возвращает экземпляр класса Plot. Сам график может включать одно или несколько выражений SymPy. По умолчанию в качестве бэкенда используется matplotlib, но вместе нее можно взять texplot, pyglet или API Google Charts.

plot(expr,range,kwargs)

где expr — это любое валидное выражение SymPy. Если не сказано другое, то по умолчанию значение range равно (-10, 10).

Следующий график показывает квадрат для каждого значения в диапазоне от -10 до 10.

>>> from sympy.plotting import plot 
>>> from sympy import * 
>>> x = Symbol('x') 
>>> plot(x**2, line_color='red')
Математическая библиотека Python SymPy

Чтобы нарисовать несколько графиков для одного диапазона, перед кортежем нужно указать несколько выражений.

Математическая библиотека Python SymPy

Также для каждого выражения можно задать отдельный диапазон.

plot((expr1,range1),(expr2,range2))

Также в функции plot() можно использовать следующие необязательные аргументы-ключевые слова.

  • line_color — определяет цвет линии графика.
  • title — название графика.
  • xlabel — метка для оси X.
  • ylabel — метка для оси Y.
>>> plot((sin(x), (x,-pi,pi)), line_color='red', title='Пример графика SymPy')
Математическая библиотека Python SymPy

Функция plot3d() рендерит трехмерный график.

>>> from sympy.plotting import plot3d 
>>> x, y = symbols('x y') 
>>> plot3d(x*y, (x, -10, 10), (y, -10, 10))
Математическая библиотека Python SymPy

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

>>> plot3d(x*y, x/y, (x, -5, 5), (y, -5, 5))

Функция plot3d_parametric_line() рендерит трехмерный линейный параметрический график:

>>> from sympy.plotting import plot3d_parametric_line 
>>> plot3d_parametric_line(cos(x), sin(x), x, (x, -5, 5))
Математическая библиотека Python SymPy

Чтобы нарисовать параметрический объемный график, используйте plot3d_parametric_surface().

Сущности

Модуль geometry в SymPy позволяет создавать двухмерные сущности, такие как линия, круг и так далее. Информацию о них можно получить через проверку коллинеарности или поиск пересечения.

Point

Класс point представляет точку Евклидового пространства. Следующие примеры проверяют коллинеарность точек:

>>> from sympy.geometry import Point 
>>> from sympy import * 
>>> x = Point(0, 0) 
>>> y = Point(2, 2) 
>>> z = Point(4, 4) 
>>> Point.is_collinear(x, y, z)
True
>>> a = Point(2, 3) 
>>> Point.is_collinear(x, a)
False
>>> x.distance(y)
2√2

Метод distance() класса Point вычисляет расстояние между двумя точками.

Line

Сущность Line можно получить из двух объектов Point. Метод intersection() возвращает точку пересечения двух линий.

>>> from sympy.geometry import Point, Line 
>>> p1, p2 = Point(0, 5), Point(5, 0) 
>>> l1 = Line(p1,p2)
>>> l2 = Line(Point(0, 0), Point(5, 5)) 
>>> l1.intersection(l2)
[Point2D(5/2, 5/2)]
>>> l1.intersection(Line(Point(0,0), Point(2,2)))
[Point2D(5/2, 5/2)]
>>> x, y = symbols('x y') 
>>> p = Point(x, y) 
>>> p.distance(Point(0, 0))

Вывод: √𝑥2+𝑦2

Triangle

Эта функция создает сущность Triangle из трех точек.

Математическая библиотека Python SymPy

Ellipse

Эллиптическая геометрическая сущность создается с помощью объекта Point, который указывает на центр, а также горизонтальный и вертикальный радиусы.

ellipse(center,hradius,vradius)
>>> from sympy.geometry import Ellipse, Line 
>>> e = Ellipse(Point(0, 0), 8, 3) 
>>> e.area
24𝜋
  • vradius может быть получен косвенно с помощью параметра eccentricity.
  • apoapsis — это наибольшее расстояние между фокусом и контуром.
  • метод equation эллипса возвращает уравнение эллипса.
Математическая библиотека Python SymPy

Множества

В математике множество — это четко определенный набор объектов, которые могут быть числами, буквами алфавита или даже другими множествами. Set — это также один из встроенных типов в Python. В SymPy же есть модуль sets. В нем можно найти разные типы множеств и операции поиска пересекающихся элементов, объединения и так далее.

Set — это базовый класс для любого типа множества в Python. Но стоит отметить, что в SymPy он отличается от того, что есть в Python. Класс interval представляет реальные интервалы, а граничное свойство возвращает объект FiniteSet.

>>> from sympy import Interval 
>>> s = Interval(1, 10).boundary 
>>> type(s)
sympy.sets.sets.FiniteSet

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

>>> from sympy import FiniteSet 
>>> FiniteSet(range(5))
{{0,1,…,4}}
>>> numbers = [1, 3, 5, 2, 8] 
>>> FiniteSet(*numbers)
{1,2,3,5,8}
>>> s = "HelloWorld" 
>>> FiniteSet(*s)
{𝐻,𝑊,𝑑,𝑒,𝑙,𝑜,𝑟}

По аналогии со встроенным множеством, Set из SymPy также является коллекцией уникальных объектов.

ConditionSet — это множество элементов, удовлетворяющих заданному условию.

Математическая библиотека Python SymPy

Union — составное множество. Оно включает все элементы из двух множеств. Если же какие-то повторяются, то в результирующем множестве будет только одна копия.

>>> from sympy import Union 
>>> l1 = [3, 7] 
>>> l2 = [9, 7, 1] 
>>> a = FiniteSet(*l1) 
>>> b = FiniteSet(*l2) 
>>> Union(a, b)
{1,3,7,9}

Intersection же включает только те элементы, которые есть в обоих множествах.

>>> from sympy import Intersection 
>>> Intersection(a, b)
{7}

ProductSet представляет декартово произведение элементов из обоих множеств.

>>> from sympy import ProductSet 
>>> l1 = [1, 2] 
>>> l2 = [2, 3] 
>>> a = FiniteSet(*l1) 
>>> b = FiniteSet(*l2) 
>>> set(ProductSet(a, b))
{(1, 2), (1, 3), (2, 2), (2, 3)}

Complement(a, b) исключает те элементы, которых нет в b.

>>> from sympy import Complement 
>>> l1 = [3, 1] 
>>> a = FiniteSet(*l1) 
>>> b = FiniteSet(*l2) 
>>> Complement(a, b), Complement(b, a)
(FiniteSet(1), FiniteSet(2))

SymmetricDifference хранит только необщие элементы обоих множеств.

>>> from sympy import SymmetricDifference 
>>> l1 = [3, 1] 
>>> a = FiniteSet(*l1) 
>>> b = FiniteSet(*l2) 
>>> SymmetricDifference(a, b)
{1,2}

Вывод в консоль

В SymPy есть несколько инструментов для вывода. Вот некоторые из них:

  • str,
  • srepr,
  • ASCII pretty printer,
  • Unicode pretty printer,
  • LaTeX,
  • MathML,
  • Dot.

Объекты SymPy также можно отправить как ввод в другие языки программирования, такие как C, Fortran, JavaScript, Theano.

SymPy использует символы Юникод для рендеринга вывода. Если вы используете консоль Python для работы с SymPy, то лучше всего применять функцию init_session().

>>> from sympy import init_session
>>> init_session()
Python console for SymPy 1.6.2 (Python 3.8.5-64-bit) (ground types: python)
...

Выполним эти команды:

>>> from __future__ import division
>>> from sympy import *
>>> x, y, z, t = symbols('x y z t')
>>> k, m, n = symbols('k m n', integer=True)
>>> f, g, h = symbols('f g h', cls=Function)
>>> init_printing()
>>> Integral(sqrt(1/x), x)
⌠
⎮     ___
⎮    ╱ 1
⎮   ╱  ─  dx
⎮ ╲╱   x
⌡

Если нет LaTeX, но есть matplotlib, то последняя будет использоваться в качестве движка рендеринга. Если и matplotlib нет, то применяется Unicode pretty printer. Однако Jupyter notebook использует MathJax для рендеринга LaTeX.

В терминале, который не поддерживает Unicode, используется ASCII pretty printer (как в выводе из примера).

Для ASCII printer есть функция pprinter() с параметром use_unicode=False.

>>> pprint(Integral(sqrt(1/x), x), use_unicode=False) 
 /
 |
 |     ___
 |    / 1
 |   /  -  dx
 | \/   x
 |
/

Также доступ к Unicode printer можно получить из pprint() и pretty(). Если терминал поддерживает Unicode, то он используется автоматически. Если поддержку определить не удалось, то можно передать use_unicode=True, чтобы принудительно использовать Unicode.

Для получения LaTeX-формата используйте функцию latex().

>>> print(latex(Integral(sqrt(1/x), x)))
\int \sqrt{\frac{1}{x}}\, dx

Также доступен printer mathml. Для него есть функция pint_mathml().

>>> from sympy.printing.mathml import print_mathml
>>> print_mathml(Integral(sqrt(1/x),x))
<apply>
        <int/>
        <bvar>
                <ci>x</ci>
        </bvar>
        <apply>
                <root/>
                <apply>
                        <power/>
                        <ci>x</ci>
                        <cn>-1</cn>
                </apply>
        </apply>
</apply>
>>> mathml(Integral(sqrt(1/x),x))
<apply><int/><bvar><ci>x</ci></bvar><apply><root/><apply><power/><ci>x</ci><cn
>-1</cn></apply></apply></apply>
Максим
Я создал этот блог в 2018 году, чтобы распространять полезные учебные материалы, документации и уроки на русском. На сайте опубликовано множество статей по основам python и библиотекам, уроков для начинающих и примеров написания программ.
Мои контакты: Почта
admin@pythonru.comAlex Zabrodin2018-10-26OnlinePython, Programming, HTML, CSS, JavaScript