Как составить уравнение в питоне

Решение линейного уравнения в python

Решение линейного уравнения в Python

В данной статье мы разберем программу на python для решения линейного уравнения Программа решает уравнение вида ax = b. Коэффициенты a и b задаются пользователем с клавиатуры. Программа находит решение и выводит его на экран. Если решений бесконечное количество или их нет, то программа оповещает об этом.
Все возможные решения линейного уравнения можно описать так
Если a = 0 и b = 0, то решений бесконечное количество.
Если a = 0 и b ≠ 0, то решений нет.
Если a ≠ 0, то единственное решение будет равно b / a.
Для задания коэффициентов с клавиатуры в Python используется функция ввода вещественного числа float(input()). Подробно о вводе информации с клавиатуры в python
a = float(input(“Введите коэффициент a “))
b = float(input(“Введите коэффициент b “))
В Python, чтобы проверить равенство двух объектов, используется ==, для проверки неравенства объектов используется !=. Для проверки двух условий одновременно используется оператор and. Подробно об условиях в python

Программа на Python для решения линейного уравнения
a = float(input(“Введите коэффициент a “))
b = float(input(“Введите коэффициент b “))
if (a == 0 and b == 0):
print(“Бесконечное количество решений.”)
if (a == 0 and b != 0):
print(“Решений нет.”)
if (a != 0):
print(b/a))

Полезно почитать по теме условия в Python примеры
Пример анкеты, опроса на Python

Библиотека Sympy: символьные вычисления в Python

Что такое SymPy ? Это библиотека символьной математики языка Python. Она является реальной альтернативой таким математическим пакетам как Mathematica или Maple и обладает очень простым и легко расширяемым кодом. SymPy написана исключительно на языке Python и не требует никаких сторонних библиотек.

Документацию и исходный код этой библиотеки можно найти на ее официальной странице.

Первые шаги с SymPy

Используем SymPy как обычный калькулятор

В библиотеке SymPy есть три встроенных численных типа данных: Real , Rational и Integer . С Real и Integer все понятно, а класс Rational представляет рациональное число как пару чисел: числитель и знаменатель рациональной дроби. Таким образом, Rational(1, 2) представляет собой 1/2 , а, например, Rational(5, 2) — соответственно 5/2 .

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

Как можно заметить, функция evalf() дает на выходе число с плавающей точкой.

В SymPy есть также класс, представляющий такое понятие в математике, как бесконечность. Он обозначается следующим образом: oo .

Символы

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

После их задания, с ними можно производить различные манипуляции.

С символами можно производить преобразования с использованием некоторых операторов языка Python. А именно, арифметических ( + , -` , “* , ** ) и логических ( & , | ,

Библиотека SymPy позволяет задавать форму вывода результатов на экран. Обычно мы используем формат такого вида:

Алгебраические преобразования

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

Раскрытие скобок

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

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

Упрощение выражений

Если вы хотите привести выражение к более простому виду (возможно, сократить какие-то члены), то используйте функцию simplify .

Также надо сказать, что для определенных видов математических функций существуют альтернативные, более конкретные функции для упрощения выражений. Так, для упрощения степенных функций есть функция powsimp , для тригонометрических — trigsimp , а для логарифмических — logcombine , radsimp .

Вычисления

Вычисления пределов

Для вычисления пределов в SymPy предусмотрен очень простой синтаксис, а именно limit(function, variable, point) . Например, если вы хотите вычислить предел функции f(x) , где x -> 0 , то надо написать limit(f(x), x, 0) .

Также можно вычислять пределы, которые стремятся к бесконечности.

Дифференцирование

Для дифференцирования выражений в SymPy есть функция diff(func, var) . Ниже даны примеры ее работы.

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

tan 2 (?)+1 Результат тот же.

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

Разложение в ряд

Для разложения выражения в ряд Тейлора используется следующий синтаксис: series(expr, var) .

Интегрирование

В SymPy реализована поддержка определенных и неопределенных интегралов при помощи функции integrate() . Интегрировать можно элементарные, трансцендентные и специальные функции. Интегрирование осуществляется с помощью расширенного алгоритма Риша-Нормана. Также используются различные эвристики и шаблоны. Вот примеры интегрирования элементарных функций:

Также несложно посчитать интеграл и от специальных функций. Возьмем, например, функцию Гаусса:

Результат вычисления можете посмотреть сами. Вот примеры вычисления определенных интегралов.

Также можно вычислять определенные интегралы с бесконечными пределами интегрирования (несобственные интегралы).

Решение уравнений

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

Как можно заметить, первое выражение функции solveset() приравнивается к 0 и решается относительно х . Также возможно решать некоторые уравнения с трансцендентными функциями.

Системы линейных уравнений

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

Факторизация

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

Булевы уравнения

Также в SymPy реализована возможность решения булевых уравнений, что по сути означает проверку булевого выражения на истинность. Для этого используется функция satisfiable() .

Данный результат говорит нам о том, что выражение (x & y) будет истинным тогда и только тогда, когда x и y истинны. Если выражение не может быть истинным ни при каких значениях переменных, то функция вернет результат False .

Линейная алгебра

Матрицы

Матрицы в SymPy создаются как экземпляры класса Matrix :

В отличие от NumPy , мы можем использовать в матрицах символьные переменные:

И производить с ними разные манипуляции:

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

При помощи библиотеки SymPy можно решать некоторые обыкновенные дифференциальные уравнения. Для этого используется функция dsolve() . Для начала нам надо задать неопределенную функцию. Это можно сделать, передав параметр cls=Function в функцию symbols() .

Теперь f и g заданы как неопределенные функции. мы можем в этом убедиться, просто вызвав f(x) .

Теперь решим следующее дифференциальное уравнение:

Чтобы улучшить решаемость и помочь этой функции в поиске решения, можно передавать в нее определенные ключевые аргументы. Например, если мы видим, что это уравнение с разделяемыми переменными, то мы можем передать в функцию аргумент hint=’separable’ .

Английский для программистов

Наш телеграм канал с тестами по английскому языку для программистов. Английский это часть карьеры программиста. Поэтому полезно заняться им уже сейчас

Математическая библиотека 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:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Числа

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

Класс Float

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

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

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

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

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

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

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

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

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

Класс Integer

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

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

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

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

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

Символы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Функция simplify()

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

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

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

Функция evalf()

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

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

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

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

Функция lambdify()

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

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

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

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

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

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

(Not), а также >> и . Булевы выражения наследуются от класса Basic .

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

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

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

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

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

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

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

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

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

Хотя SymPy и предлагает операторы ^ для Xor ,

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

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

Запросы

Модуль assumptions в SymPy включает инструменты для получения информации о выражениях. Для этого используется функция 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
Предикат для проверки того, является ли число нулем или нет.

[spoiler title=”источники:”]

http://pythonru.com/biblioteki/sympy-v-python

[/spoiler]

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 требуется одна важная библиотека под названием 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 квадратные корни чисел, которые не являются идеальными квадратами, просто не вычисляются:

import sympy

print(sympy.sqrt(7))

Вот каким будет вывод этого кода: 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:

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

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

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

Числа

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

Класс Float

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

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

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

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

>>> Float('1.33E5')
133000.0

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

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

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

Rational(0.2).limit_denominator(100)

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

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

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

>>> 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:

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

Символы

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

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

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

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

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

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

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

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

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

from sympy.abc import x, z

Однако 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:

>>> 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 (, line 1)

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

Функция 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().

f = lambdify([a, b], expr, "numpy")

В этой функции использовались два массива 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??+?².

Вывод: ?²−?².

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

>>> expand((x + 1)*(x - 2) - (x - 1)*x)
-2

factor

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

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

Вывод: ?(?+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

Вывод: ?³−?²?+2?²+??+?−3.

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

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

Вывод: ?³+?²(?+4?)+?(4??+2?).

cancel

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

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

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

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

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

>>> expr = x**y*x**z*y**z 
>>> expr

Вывод: ?^??^??^?.

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

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

Вывод: ?^?(??)^?.

combsimp

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

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

>>> combsimp(expr)
?(?−2)(?−1)

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(?²)+1.

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

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

>>> expr = x*sin(x*x) + 1 
>>> expr.diff(x)

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

Неоцененная производная создается с помощью класса 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 — Возвращает мнимую часть выражения:

>>> im(5+3*I)
3
>>> im(I)
1

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 — Функция возвращает сопряжение комплексного числа. Для поиска меняется знак мнимой части.

>>> conjugate(4+7*I)
4−7?

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

В 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()

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

pow()

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

>>> q1.pow(2)
(−3)+4?+0?+0?

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

Функция 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) — это невычисленная функция. Ее производная:

Сначала создается объект 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')

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

>>> plot(sin(x), cos(x), (x, -pi, pi))

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

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

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

• line_color — определяет цвет линии графика.
• title — название графика.
• xlabel — метка для оси X.
• ylabel — метка для оси Y.

>>> plot((sin(x), (x,-pi,pi)), line_color='red', title='Пример графика SymPy')

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

>>> from sympy.plotting import plot3d 
>>> x, y = symbols('x y') 
>>> plot3d(x*y, (x, -10, 10), (y, -10, 10))

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

>>> 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))

Чтобы нарисовать параметрический объемный график, используйте 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))

Вывод: √?²+?²

Triangle

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

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 эллипса возвращает уравнение эллипса.

Множества

В математике множество — это четко определенный набор объектов, которые могут быть числами, буквами алфавита или даже другими множествами. 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 — это множество элементов, удовлетворяющих заданному условию.

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))

        
        
                x
        
        
                
                
                        
                        x
                        -1
                
        

>>> mathml(Integral(sqrt(1/x),x))
xx-1