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

3

Numpy: решение системы линейных уравнений методом Гаусса

Пытаюсь в Python создать алгоритм расчета СЛАУ методом Гаусса. Метод заключается в следующем. Составляем матрицу коэффициентов, включая свободный член. Затем приводим матрицу к треугольному виду. Для этого сначала по первому столбцу (с индексом 0) каждый элемент делим на диагональный (a0,0) (в примере — 3,8), вычисляя индекс m, а после пересчитываем строку 2 по формуле: каждый ее элемент (без элемента свободного члена из последнего столбца) минус произведение элемента над ним (из нулевой строки) и индекса m для второй строки. Отдельно отработаем со столбцом свободного члена (здесь алгоритм неважен).

Следом аналогичные действия надо проделать для третьей строки элементов (но учитывая, что на первой итерации элементы второй строки преобразованы вышеописанным алгоритмом, а коэффициент m будет считаться по второму столбцу: соответственно делим все его элементы на диагональный элемент из 2-й строки a1,1) (в примере 1,3). Вопрос: я рассчитал вектор-столбец m: m = ([1,000, 1,684, 0,632])

И теперь надо отработать со второй строкой матрицы. И вот здесь сложность с индексацией. Во-первых, не могу перебрать значения m, тип которых float. Во-вторых, неверно задаю индексацию элементов второй строки (по сути — после нулевой это первая строка)

В конце приведена ссылка на jupyter notebook с более-менее полным решателем СЛАУ. Плюс трюк, как считать на pyton почти так же быстро, как на Фортране 🙂

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

Результат для вашего примера:

В чём засада. В ходе вычислений может оказаться ноль на диагонали.

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

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

Результат для вашего примера: make_identity(gaussFunc(np.copy(matrix)))

Вырезаем последний столбец, получим строку корней: roots = make_identity(gaussFunc(np.copy(matrix)))[:,3]

Умножаем найденные корни на исходную матрицу и сравниваем с последним столбцом исходной задачи: np.matmul(matrix[. 3], roots.T) — matrix[:,3]

Результат вычисления array([ 0.00000000e+00, -4.44089210e-16, -2.22044605e-16])

Следовательно, корни найдены правильно. С чем и поздравляю.

UPDATE

Метод Гаусса с выбором главного элемента. Плюс добавлена обработка нуля на диагонали.

В этой функции главный фокус в том, как переставлять строки. Простая формула matrix[nrow], matrix[pivot] = matrix[pivot], matrix[nrow] не работает. При таком присваивании справа стоят указатели на строку, а слева — адреса, куда нужно скопировать значения. То есть при первом присваивании в строку nrow будет скопирована строка pivot , а в строку pivot — содержимое строки nrow — но оно уже переписано из строки pivot ! То есть фактически строка pivot скопируется в саму себя. И вместо перестановки двух строк будет копия одной строки.

matrix[[nrow, pivot]] = matrix[[pivot, nrow]] — работает. И c явным копированием тоже работает: matrix[nrow], matrix[pivot] = matrix[pivot], np.copy(matrix[nrow])

UPDATE 2

Помимо собственно решателя дано сравнение с Си-шным решателем numpy.linalg.solve и трюк как ускорить скорость счёта решателя на пайтоне в 20 раз, что почти так же быстро, как чисто Си-шный решатель.

Строго говоря, решатель в numpy даже не Си-шный, а фортрановский LAPACK gesv

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

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

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

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

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

• как установить scipy.linalg и подготовить среду выполнения кода;
• как работать с векторами и матрицами с помощью NumPy;
• почему scipy.linalg лучше, чем numpy.linalg;
• как формализовать задачи с использованием систем линейных алгебраических уравнений;
• как решать СЛАУ с помощью scipy.linalg (на реальном примере).

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

Если готовы к этому — приглашаю под кат. Хотя, честно говоря, некоторые разделы можно пропускать — например, основы работы с векторами и матрицами в 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(), передав туда список значений в качестве аргумента:

По аналогии с матрицами, используем .shape(), чтобы вывести на экран размерность вектора:

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

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

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

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

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

В приведённом выше примере мы использовали .reshape() для получения вектора-столбца с размерностью (3, 1) из вектора с размерностью(3,). Стоит отметить, что .reshape() делает преобразование с учётом того, что количество элементов (100% заполненных мест) в массиве с новой размерностью должно быть равно количеству элементов в исходном массиве.

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

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

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

В качестве аргумента .zeros() нужно указать размерность массива, упакованную в кортеж (перечислить значения через запятую и обернуть это в круглые скобки). Элементы созданного массива получат тип float64.

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

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

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

Говоря точнее, метод .random.rand() возвращает массив с псевдослучайными значениями (от 0 до 1) из множества, сгенерированного по закону равномерного распределения. Обратите внимание, что в отличие от .zeros() и .ones(), .random.rand () на вход принимает не кортеж, а просто два значения через запятую.

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

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

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

В официальной документации сказано, что scipy.linalg содержит все функции numpy.linalg, а также дополнительные функции, не входящие в numpy.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. Таким образом, мы можем решить систему так:

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

1. Строки 1 и 2: импортируем NumPy и функцию solve() из scipy.linalg.
2. Строки с 4 по 9: создаём матрицу коэффициентов как двумерный массив с именем A.
3. Строка 11: создаём вектор-строку b как массив с именем b. Чтобы сделать его вектор-столбцом, вызываем .reshape ((2, 1)).
4. Строки 13 и 14: вызываем .solve() для нашей системы, результат сохраняем в х и выводим его. Обратите внимание, что .solve() возвращает вектор из чисел с плавающей запятой, даже если все элементы исходных массивов являются целыми числами.

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

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

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

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

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

• 170 единиц витамина А;
• 180 единиц витамина B;
• 140 единиц витамина С;
• 180 единиц витамина D;
• 350 единиц витамина Е.

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

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

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

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

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

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

• 10 единиц продукта 1;
• 10 единиц продукта 2;
• 20 единиц продукта 3;
• 20 единиц продукта 4;
• 10 единиц продукта 5.

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

Решение систем линейных уравнений в Python¶

Рассмотрим простую систему из 2 линейных уравнений с 2 неизвестными:

\begin 2x+5y=1 &(1) \\ x-10y=3 &(2) \end

Система легко решается аналитически. Для этого достаточно выразить из уравнения (2) переменную x:

\begin x=3 + 10y &(3) \end

После чего подставить её в уравнение (1): \begin 2\cdot(3 + 10y)+5y=1, \end и решить получившееся линейное уравнение относительно переменной y: \begin 25y+6=1 \ \end

Полученное значение y можно подставить в выражение для x в уравнение (3): \begin x=3 + 10\cdot (-0.2) \end и получить значение переменной x: \begin x=1 \end Таким образом решением системы будет: (1; -0,2)

(1-е значение в ответе — x, 2-е — y)

Решение матричным методом (python numpy)¶

Запишем исходную систему уравнений в виде матрицы (левая часть) и вектора (правая часть): \begin 2x+5y=1 \\ x-10y=3 \end

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

Коэффициент перед переменной х 1й строки на место в матрице с координатами 0,0. (2)

Коэффициент перед переменной y 1й строки на место в матрице с координатами 0,1. (5)

Коэффициент перед переменной х 2й строки на место в матрице с координатами 1,0. (1)

Коэффициент перед переменной y 2й строки на место в матрице с координатами 1,1. (-10)

\begin 2& 5 \\ 1 & -10 \end

Значение свободного члена (число, не умноженное ни на одну переменную системы) после знака равенства 1й строки на место 0 в векторе.

Значение свободного члена 2й строки на место 1 в векторе.

Для этого воспользуемся numpy массивами:

Для решения системы воспользуемся функцией numpy.linalg.solve модуля numpy (документация — http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.solve.html). Функция принимает на вход 2 параметра:

1й — матрица коэффициентов перед переменными

2й — вектор свободных членов

Обратим внимание, что ответом так же является numpy массив!

при этом порядок следования ответов в массиве соответствует порядку столбцов исходной матрицы. Т.е. на 0 месте находится x=1, т.к. мы в матрице внесли в 0 столбец коэффициенты перед переменной х!

Ответ: (1; -0,2)

Рассмотрим простую систему из 2 линейных уравнений с 2 неизвестными: \begin A + C = 2 &(4) \\ -A + B — 2C + D = -2 &(5) \\ 4A + C — 2D = 0 &(6) \\ -4A + 4B + D = 5 &(7) \end

Для наглядности решения данной системы матричным методом запишем её в таком виде, чтобы каждое уравнение содержало все 4 переменных, и чтобы они занимали в каждой строке одно и то же порядковое место (А — 0, B — 1, C — 2, D — 3):

\begin A + 0B + C + 0D = 2 &(8) \\ -A + B — 2C + D = -2 &(9) \\ 4A + 0B + C — 2D = 0 &(10) \\ -4A + 4B + 0C + D = 5 &(11) \end

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

\begin 1 & 0 & 1 & 0 \\ -1 & 1 & -2 & 1 \\ 4 & 0 & 1 & -2 \\ -4 & 4 & 0 & 1 \end\begin 2 \\ -2 \\ 0 \\ 5 \end

Ответ: (0; 1; 2; 1)

A = 0, B = 1, C =2, D = 1

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

\begin 2x_<1>+x_<2>^2+x_ <3>= 2 &(12) \\ x_<1>-x_<2>^2 = -2 &(13) \\ 3x_<1>-x_<2>^2+2x_ <3>= 2 &(14) \end

Можно заметить, что переменная x2 входит во все 3 уравнения только в квадратичной форме. Это означает, что мы можем осуществить замену:

С учётом этой подстановки запишем систему, аналогично примеру 2 с вхождением всех 3 переменных:

\begin 2x_<1>+a+x_ <3>= 2 &(16) \\ x_<1>-a+0x_ <3>= -2 &(17) \\ 3x_<1>-a+2x_ <3>= 2 &(18) \end

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

\begin 2 & 1 & 1 \\ 1 & -1 & 0 \\ 3 & -1 & 2 \end\begin 2 \\ -2 \\ 2 \end

Мы получили промежуточный результат:

$x_<2>^2=1$ соответствует 2 значениям $x_<2>$: 1 и -1.

Таким образом мы получаем 2 решения нашей системы: $x_<1>= -1, x_<2>= 1, x_<3>= 3,$ и $x_<1>= -1, x_<2>= -1, x_<3>= 3,$

Ответ: (-1; 1; 3) и (-1; -1; 3)

Навстречу друг другу из одного города в другой, расстояние между которыми составляет 30 км, едут два велосипедиста. Предположим, что если велосипедист 1 выедет на 2 ч раньше своего товарища, то они встретятся через 2,5 часа после отъезда велосипедиста 2; если же велосипедист 2 выедет 2мя часами ранее велосипедиста 1, то встреча произойдет через 3 часа после отъезда первого. С какой скоростью движется каждый велосипедист?

Обозначим за неизвестные x и y скорости велосипедистов.

Путь = скорость * время

Расстояние между велосипедистами = путь 1 велосипедиста + путь 2 велосипедиста

На основании этих простых рассуждений и данных задачи можно записать уравнения:

\begin (2.5 + 2)x+2.5y=30 &(19) \\ 3x + (3+2)y=30 &(20) \end

\begin 4.5x+2.5y=30 &(21) \\ 3x + 5y=30 &(22) \end

Аналогично примеру 1 легко составим матрицу коэффициентов перед неизвестными (левая часть системы) и вектор со свободными членами (права часть системы):

\begin 4.5& 2.5 \\ 3 & 5 \end\begin 30 \\ 30 \end

Ответ: 5км/ч и 3км/ч

Уравнение плоскости в 3-х мерном пространстве задаётся уравнением: \begin z = ax + by + c & (23) \end Уравнение плоскости однозначно задаётся 3 точками через которые она проходит.

Таким образом легко понять, что если мы знаем координаты точек, через которые проходит плоскость, то в уравнении (23) у вас 3 переменных: a, b, c. А значения x, y, z нам известны для 3 точек.

Если плоскость проходит через точки (1;-6;1), (0;-3;2) и (-3;0;-1), то мы легко можем найти коэффициенты, подставив значения соответствующих координат для всех 3 точек в уравнение (23) и получив систему из 3 уравнений.

Для точки x = 1, y = -6, z = 1: \begin a\cdot 1 + b\cdot (-6) + c = 1 &(24) \end

Для точки x = 0, y = -3, z = 2: \begin a\cdot 0 + b\cdot (-3) + c = 2 &(25) \end

Для точки x = -3, y = 0, z = -1: \begin a\cdot (-3) + b\cdot 0 + c = -1 &(26) \end

На основании системы уравнений (24), (25), (26) можно записать матрицу коэффициентов перед неизвестными (левая часть матрицы):

\begin 1& -6 & 1 \\ 0 & -3 & 1 \\ -3 & 0 & 1 \end

И вектор свободных членов (правая часть): \begin 1 \ 2 \ -1 \end

Ответ: уравнение искомой плоскости в пространстве задаётся уравнением $z = 2x + y + 5$

Пример 6. Нахождение уравнения параболы по 2 точкам и касательной¶

Найти уравнение параболы ($f(x) = ax^2 + bx + x & (27)$), проходящей через точки (1,1) и (-1,1) и касающейся биссектрисы 1й координатной четверти.

Как и в предыдущем примере неизвестными для нас являются коэффициенты a, b, c.

Подставив в уравнение параболы (27) значения аргумента (x) и функции (f(x)) получим 2 уравнения:

\begin a\cdot 1^2 + b\cdot 1 + c = 1 &(28) \\ a\cdot (-1)^2 + b\cdot (-1) + c = 1 &(29) \end

Однако для нахождения 3 неизвестных 2 уравнений мало. Необходимо найти ещё одно из оставшихся условий.

Касание биссектрисы 1й координатной четверти означает, что наша парабола имеет касательную $y = x$. Если посмотреть на условие задачи, то мы увидим, что одна из точек (1, 1) лежит на этой прямой. Это означает, что мы знаем точку касания.

Уравнение прямой, делящей 1-ю координатную четверть пополам (биссектрисы) имеет вид $y = kx \quad (30)$

При этом мы знаем, что угол уравнения касательной (коэффициент k уравнения (30)) равен производной от функции (27) в точке касания.

\begin f'(x) = 2ax + bx & (31) \end

Подставив значение аргумента (x = 1) в точке касания и коэффициента (k = 1 в качестве производной f'(x))

\begin 1 = 2a\cdot1 + b\cdot1 & (32) \end

Используя уравнения (28), (29) и (32), запишем полную систему уравнений, которую нам необходимо решить:

\begin a\cdot 1 + b\cdot 1 + c \cdot 1 = 1 &(33) \\ a\cdot 1 + b\cdot (-1) + c \cdot 1 = 1 &(34) \\ a\cdot 2 + b\cdot 1 + c \cdot 0 = 1 &(35) \end

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

\begin 1& 1 & 1 \\ 1 & -1 & 1 \\ 2 & 1 & 0 \end\begin 1 \\ 1 \\ 1 \end

Ответ: уравнение искомой параболы задаётся функцией $f(x) = 0.5x^2 + 0.5$

На иллюстрации ниже изображены графики параболы и биссектрисы, которой она касается. А так же 2 точки, через которых проходит парабола.

Решение систем линейных уравнений с помощью Numpy в Python

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

Что такое система линейных уравнений?

Википедия определяет систему линейных уравнений как:

В математике система линейных уравнений (или линейная система) – это набор двух или более линейных уравнений, включающих один и тот же набор переменных.

Конечная цель решения системы линейных уравнений – найти значения неизвестных переменных. Вот пример системы линейных уравнений с двумя неизвестными переменными x и y:

Чтобы решить указанную выше систему линейных уравнений, нам нужно найти значения переменных x и y. Есть несколько способов решить такую систему, например, исключение переменных, правило Крамера, метод сокращения строк и матричное решение.

В матричном решении решаемая система линейных уравнений представлена в виде матрицы AX = B. Например, мы можем представить уравнение 1 в виде матрицы следующим образом:

Чтобы найти значение переменных x и y в уравнении 1, нам нужно найти значения в матрице X. Для этого мы можем взять скалярное произведение обратной матрицы A и матрицы B, как показано ниже:

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

Решение

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

Давайте теперь посмотрим, как решить систему линейных уравнений с помощью библиотеки Numpy.

Использование методов inv() и dot()

Сначала мы найдем матрицу, обратную матрице A, которую мы определили в предыдущем разделе.

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

В следующем скрипте мы создаем список с именем m_list, который дополнительно содержит два списка: [4,3] и [-5,9]. Эти списки представляют собой две строки в матрице A. Чтобы создать матрицу A с помощью Numpy, m_list передается методу массива, как показано ниже:

Чтобы найти обратную матрицу, которая передается методу linalg.inv() модуля Numpy:

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

Чтобы найти точечный продукт с помощью библиотеки Numpy, используется функция linalg.dot(). Следующий скрипт находит скалярное произведение между обратной матрицей A и B, которая является решением уравнения 1.

Здесь 2 и 4 – соответствующие значения для неизвестных x и y в уравнении 1. Чтобы убедиться, что если вы подставите 2 вместо неизвестного x и 4 вместо неизвестного y в уравнении 4x + 3y, вы увидите что результат будет 20.

Давайте теперь решим систему трех линейных уравнений, как показано ниже:

Вышеупомянутое уравнение можно решить с помощью библиотеки Numpy следующим образом:

В приведенном выше скрипте методы linalg.inv() и linalg.dot() связаны вместе. Переменная X содержит решение уравнения 2 и печатается следующим образом:

Значения неизвестных x, y и z равны 5, 3 и -2 соответственно. Вы можете подставить эти значения в уравнение 2 и проверить их правильность.

resolve()

В двух предыдущих примерах мы использовали методы linalg.inv() и linalg.dot() для поиска решения системы уравнений. Однако библиотека Numpy содержит метод linalg.solve(), который можно использовать для непосредственного поиска решения системы линейных уравнений:

Вы можете видеть, что результат такой же, как и раньше.

Пример

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

Предположим, продавец фруктов продал 20 манго и 10 апельсинов за один день на общую сумму 350 долларов. На следующий день он продал 17 манго и 22 апельсина за 500 долларов. Если цены на фрукты оставались неизменными в оба дня, какова была цена одного манго и одного апельсина?

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

Допустим, цена одного манго равна x, а цена апельсина – y. Вышеупомянутую проблему можно преобразовать так:

Решение для указанной выше системы уравнений показано здесь:

И вот результат:

Выходные данные показывают, что цена одного манго составляет 10 долларов, а цена одного апельсина – 15 долларов.