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

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

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

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

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

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

Символы

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

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

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

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

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

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

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

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

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

Вычисления

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Матрицы

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

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

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

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

Источник

Как решать квадратные уравнения в Python

Если квадратные уравнения являются классической задачей в математике, то они также являются классической задачей в программировании. Их решение – идеальное упражнение для тех, кто только начинает программировать, поскольку оно включает ввод с клавиатуры, вывод на экран, арифметические и условные вычисления. Вы хотите узнать, как решать уравнения второй степени в Python?

Об этом я подробно расскажу в этой статье.

Итак, представьте уравнение ax² + bx + c = 0:

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

Получение значений коэффициентов

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

Для получения значения, предоставленного пользователем, можно использовать функцию ввода, которая ждет, пока пользователь введет значение и нажмет клавишу Enter. Значение, предоставленное пользователем, возвращается функцией в виде текстовой строки, которую нам нужно преобразовать в десятичное число с помощью функции float.

В этом случае мы должны запросить у пользователя три значения, так как три – это коэффициенты, которые обрабатываются в уравнении второй степени, которое, как вы помните, имеет следующий вид: ax² + bx + c = 0, где x – неизвестное, которое нужно вычислить, а a, b и c – коэффициенты.

Обратите внимание, что уравнение второй степени не определено, если коэффициент a равен 0, поэтому можно предположить, что значение этого коэффициента всегда будет отлично от 0.

Также возможно, что пользователь вводит не числовые значения при запросе. Это нужно проверить в нашей программе, чтобы избежать нарушения выполнения программы. Я не буду рассказывать об этом здесь, чтобы не делать эту статью слишком длинной, но я объясню в другой статье, как запрашивать у пользователя значение до тех пор, пока оно не станет правильным. Следуя указаниям в этой статье, вы можете проверить, что коэффициент a отличен от 0 и что введенные значения являются числовыми.

Таким образом, для данной программы мы будем считать, что пользователь всегда вводит правильные значения для коэффициентов a, b и c. Запросить их можно следующим образом:

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

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

Чтобы улучшить этот код, я собираюсь использовать функции сжатия и распаковки списков.

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

Итак, я могу создать список с тремя значениями (три коэффициента), используя следующий код:

В предыдущем коде я прохожу по кортежу (‘a’, ‘b’, ‘c’), делая вызов input (и соответствующего вызова float) для каждого из его значений. В итоге полученные значения сохраняются в списке.

Теперь настала очередь распаковки.

Так, если, например, я сделаю следующее a, b, c = [1, 2, 3], то легко увидеть, что значения 1, 2 и 3 будут соответствовать переменным a, b и c и именно в таком порядке.

Комбинируя теперь две предыдущие инструкции, мы можем получить от пользователя три коэффициента для нашего уравнения без повторения кода и в одной строке (предполагая, как и раньше, что значения, введенные пользователем, будут действительными):

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

Вычисление дискриминанта

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

Если вы остановитесь и проанализируете ее, то увидите, что вам нужно вычислить квадратный корень из выражения b² – 4ac.

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

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

Вычислить квадрат величины очень легко, умножив эту величину на саму себя. Поэтому, если мы хотим получить значение b в квадрате, то есть b², мы можем сделать b * b, как показано в коде выше.

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

Уравнения второй степени не имеющие решения

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

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

Это делается очень простым способом с помощью условия:

Если дискриминант больше или равен нулю, то мы имеем решение, и остается только вычислить его.

Вычисление решений (или решения)

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

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

Мы также должны учесть это при вычислении решения уравнения, так что нам придется получить два разных значения: одно с учетом положительного результата корня, а другое – с учетом отрицательного.

Для этого, всегда предполагая, что дискриминант является неотрицательным числом, мы можем вычислить два различных решения уравнения следующим образом:

Обратите внимание, что сначала я вычисляю положительное значение корня с помощью функции sqrt, которая находится в модуле math. Не забудьте выполнить from math import sqrt, чтобы иметь возможность использовать его. Причина вычисления его заранее, поскольку я также ранее сохранил значение дискриминанта в переменной, заключается в том, чтобы избежать повторения кода при вычислении двух решений x_1 и x_2. Это также делает код более четким, легко читаемым и менее склонным к ошибкам.

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

Интересно также выделить такую ситуацию. Для этого достаточно проверить, что дискриминант равен 0, и таким образом вычислить единственное решение в этом случае. Это можно сделать следующим образом:

Теперь остается только вывести решения на экран. Вы увидите это ниже, когда мы соберем воедино весь код, который уже видели.

Полный код

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

Вы видите, что после предыдущих объяснений полный код получился простым и лаконичным. Давайте посмотрим результаты выполнения некоторых операций, чтобы вы могли увидеть, как это работает. Первый – это прогон, в котором решаемое уравнение второй степени имеет два различных решения (т.е. дискриминант больше 0):

Теперь рассмотрим случай, когда существует только одно решение (или двойное решение, когда дискриминант равен 0):

И, наконец, вариант, в котором не существует реального решения, потому что дискриминант отрицательный:

Создание функции для решения квадратных уравнений

Теперь мы поместим наш код в функцию, которая получает коэффициенты a, b и c и возвращает решение или решения уравнения. Это удобно, если нам нужно решить несколько уравнений в нашей программе.

Мы будем думать о функции так, чтобы она возвращала список значений, поскольку, как мы видели, реально возможные решения могут быть 0, 1 или 2. Таким образом, достаточно проверить длину списка, возвращаемого нашей функцией, чтобы узнать количество решений уравнения.

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

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

Обратите внимание, что, хотя мы могли бы запросить у пользователя значения коэффициентов, как мы делали это ранее, в данном случае мы собираемся предоставить их напрямую:

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

Проверка решений

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

Для этого нам нужно определить функцию, которая принимает четыре различных параметра, где три из них будут коэффициентами a, b и c, а другой – значением проверяемого x.

Эта функция должна будет подставить эти четыре значения в общее выражение квадратного уравнения ax² + bx + c = 0 и проверить, что равенство выполняется.

Обратите внимание, что мы должны провести сравнение вещественных чисел. Всякий раз, когда нам приходится это делать, мы должны определить небольшой предел допустимой погрешности, в пределах которого мы можем считать два действительных числа равными. Это связано с тем, что, например, два числа 1.000000 и 1.000001 различны, если сравнивать их с помощью компаратора равенства ==, но в нашем случае мы можем захотеть считать их равными числами.

Таким образом, определив переменную margin как небольшую погрешность, например, 0,0001 (одна десятитысячная), наш код должен будет считать, что два числа, вычитание которых по абсолютной величине (для устранения отрицательного знака результата) меньше этой погрешности, равны. Таким образом, если взять числа d и e, то наше сравнение будет уже не d == e, а abs(d – e) Сохраните статью в социальных сетях, чтобы не потерять.

Источник

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

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

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

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

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

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

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

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

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

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

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

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

Функция S()

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

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

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

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

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

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

Метод subs(. )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вывод

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

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

Источник

Решаем систему линейных алгебраических уравнений с Python-пакетом scipy.linalg (не путать с numpy.linalg)

Аппарат линейной алгебры применяют в самых разных областях — в линейном программировании, эконометрике, в естественных науках. Отдельно отмечу, что этот раздел математики востребован в машинном обучении. Если, например, вам нужно поработать с матрицами и векторами, то, вполне возможно, на каком-то шаге вам придётся решать систему линейных алгебраических уравнений (СЛАУ).

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

Я расскажу про один из таких инструментов — Python-пакет scipy.linalg из библиотеки SciPy, который позволяет быстро и эффективно решать многие задачи с использованием аппарата линейной алгебры.

В этом туториале вы узнаете:

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

Если готовы к этому — приглашаю под кат. Хотя, честно говоря, некоторые разделы можно пропускать — например, основы работы с векторами и матрицами в NumPy (если вы хорошо знакомы с ним).

Установка scipy.linalg

SciPy — это библиотека Python с открытым исходным кодом для научных вычислений: решение СЛАУ, оптимизация, интеграция, интерполяция и обработка сигналов. Помимо linalg, она содержит несколько других пакетов — например, NumPy, Matplotlib, SymPy, IPython и pandas.

Среди прочего, scipy.linalg содержит функции для с работы с матрицами — вычисление определителя, инверсия, вычисление собственных значений и векторов, а также сингулярное разложение.

Чтобы использовать scipy.linalg, вам необходимо установить и настроить библиотеку SciPy. Это можно сделать с помощью дистрибутива Anaconda, а также системы управления пакетами и инсталлятора Conda.

Для начала подготовьте среду выполнения для библиотеки:

Установите необходимые пакеты:

Эта команда может работать долго. Не пугайтесь!

Я предлагаю использовать Jupyter Notebook для запуска кода в интерактивной среде. Это не обязательно, но лично мне он облегчает работу.

Перед открытием Jupyter Notebook вам необходимо зарегистрировать экземпляр conda linalg, чтобы использовать его в качестве ядра при создании ноутбука. Для этого выполните следующую команду:

Теперь можно открыть Jupyter Notebook:

Когда он загрузится в вашем браузере, создайте новый notebook, нажав New → linalg:

Чтобы убедиться, что установка библиотеки SciPy прошла успешно, введите в ноутбуке:

NumPy для работы с векторами и матрицами (куда же без него)

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

NumPy — это наиболее популярный пакет для работы с матрицами и векторами в Python. Часто его применяют в сочетании с scipy.linalg. Чтобы начать работу с матрицами и векторами, нужно импортировать пакет NumPy:

Для представления матриц и векторов NumPy использует специальный тип, называемый ndarray. Чтобы создать объект ndarray, вы можете использовать array ().

Например, вам нужно создать следующую матрицу:

Создадим матрицу как набор вложенных списков (векторов-строк):

Заметьте, что приведённый выше вывод (Outp[3]) достаточно наглядно показывает получившуюся матрицу.

И ещё: все элементы матрицы должны и будут иметь один тип. Это можно проверить с помощью dtype.

Здесь элементы являются целыми числами, поэтому их общий тип по умолчанию — int64. Если бы среди них было хотя бы одно число с плавающей точкой, все элементы получили бы тип float64:

Чтобы вывести на экран размерность матрицы, можно использовать метод shape:

Как и ожидалось, размерность матрицы A 3×2, то есть A имеет три строки и два столбца.

При работе с матрицами часто приходится использовать операцию транспонирования, которая столбцы превращает в строки и наоборот. Чтобы транспонировать вектор или матрицу (представленную объектом типа ndarray), вы можете использовать .transpose () или .T. Например:

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

Заметьте, что она выглядит как (3,), а не как (3, 1) или (1, 3). Разработчики NumPy решили сделать отображение размерности векторов так же, как в MATLAB.

Чтобы получить на выходе размерность (1, 3), нужно было бы создать вот такой массив:

Для (3, 1) — вот такой:

Как видите, они не идентичны.

Часто возникает задача из вектора-строки сделать вектор-столбец. Как вариант, можно сначала создать вектор-строку, а потом использовать .reshape() для его преобразования в столбец:

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

Заполнение массивов данными

NumPy позволяет быстро создавать и заполнять массивы. Например, чтобы создать массив, заполненный нулями, можно использовать .zeros():

Точно так же, для создания массивов из единиц можно использовать .ones ():

Элементы созданного массива также получат тип float64.

Создать массив, заполненный случайными числами, поможет .random.rand():

Чтобы получить массив с псевдослучайными значениями, взятыми из множества, сгенерированного по закону нормального распределения с нулевым средним и единичной дисперсией, вы можете использовать .random.randn():

Почему scipy.linalg лучше, чем numpy.linalg

NumPy имеет встроенный модуль numpy.linalg для решения некоторых задач, связанных с аппаратом линейной алгебры. Обычно scipy.linalg рекомендуют использовать по следующим причинам:

В следующем разделе мы применим scipy.linalg для работы с системами линейных алгебраических уравнений. Наконец-то практика!

Формализация и решение задач с scipy.linalg

Пакет scipy.linalg может стать полезным инструментом для решения транспортной задачи, балансировки химических уравнений и электрических нагрузок, полиномиальной интерполяции и так далее.

В этом разделе вы узнаете, как использовать scipy.linalg.solve() для решения СЛАУ. Но прежде чем приступить к работе с кодом, займёмся формализацией задачи и далее рассмотрим простой пример.

Система линейных алгебраических уравнений — это набор из m уравнений, n переменных и вектора свободных членов. Прилагательное «линейных» означает, что все переменные имеют первую степень. Для простоты рассмотрим СЛАУ, где m и n равны 3:

Есть ещё одно требование к «линейности»: коэффициенты K₁ … K₉ и вектор b₁ … b₃ должны быть константами (в математическом смысле этого слова).

В реальных задачах СЛАУ обычно содержат большое количество переменных, что делает невозможным решение систем вручную. К счастью, такие инструменты, как scipy.linalg, могут выполнить эту тяжелую работу.

Задача 1

Мы сначала разберёмся с основами scipy.linalg.solve() на простом примере, а в следующем разделе возьмём задачу посложнее.

Перейдём к матричной записи нашей системы и введём соответствующие обозначения — A, x и b:

Заметьте: левая часть в исходной записи системы — это обычное произведение матрицы A на вектор x.

Всё, теперь можно переходить к программированию.

Пишем код, используя scipy.linalg.solve()

Входными данными для scipy.linalg.solve() будут матрица A и вектор b. Их нужно представить в виде двух массивов: A — массив 2х2 и b — массив 2х1. В этом нам как раз поможет NumPy. Таким образом, мы можем решить систему так:

Разберём приведённый выше код:

Далее возьмём более сложный пример из реальной практики.

Задача 2: составление плана питания

Это одна из типовых задач, встречающихся на практике: найти пропорции компонентов для получения определенной смеси.

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

Нам даны нормы содержания витаминов в пище:

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

Обозначим оптимальную концентрацию (количество единиц) для продукта 1 как x1, для продукта 2 — как x2 и так далее. Так как мы будем смешивать продукты, то для каждого витамина (столбца таблицы) можно просто просуммировать значения, по всем продуктам. Учитывая, что сбалансированная диета должна включать 170 единиц витамина А, то, используя данные из столбца «Витамин А», составим уравнение:

Аналогичные уравнения можно составить и для витаминов B, C, D, E, объединив всё в систему:

Запишем полученную СЛАУ в матричной форме:

Теперь для решения системы можно использовать scipy.linalg.solve():

Мы получили результат. Давайте его расшифруем. Сбалансированная диета должна включать:

Облачные VPS-серверы с быстрыми NVMе-дисками и посуточной оплатой. Загрузка своего ISO.

Источник