Как сделать систему уравнений в питоне

Библиотека 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 с ревью кода от преподавателя

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

Два или более линейных уравнения с одинаковым набором переменных называются системой линейных уравнений. Мы можем решить эти переменные в Python с помощью Numpy.

• Автор записи

Автор: Guest Contributor
Дата записи

Библиотека Numpy может использоваться для выполнения различных математических/научных операций, таких как матричные кросс-и точечные произведения, поиск значений синуса и косинуса, преобразование Фурье и манипулирование формой и т. Д. Слово Numpy-это сокращенное обозначение “Числового питона”.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Реальный Пример

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

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

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

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

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

Результат показывает, что цена одного манго составляет 10 долларов, а цена одного апельсина-15 долларов.

Как сделать систему уравнений в питоне

NumPy : матрицы и операции над ними

В этом ноутбуке из сторонних библиотек нам понадобится только NumPy . Для удобства импортируем ее под более коротким именем:

Приведем несколько способов создания матриц в NumPy .

Самый простой способ — с помощью функции numpy.array(list, dtype=None, . ).

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

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

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

Второй способ создания — с помощью встроенных функций numpy.eye(N, M=None, . ), numpy.zeros(shape, . ), numpy.ones(shape, . ).

Первая функция создает единичную матрицу размера N \times M; если M не задан, то M = N.

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

Примеры:

Обратите внимание: размерность массива задается не двумя аргументами функции, а одним — кортежем!

Вот так — np.ones(7, 5) — создать массив не получится, так как функции в качестве параметра shape передается 7 , а не кортеж (7, 5) .

И, наконец, третий способ — с помощью функции numpy.arange([start, ]stop, [step, ], . ), которая создает одномерный массив последовательных чисел из промежутка [start, stop) с заданным шагом step, и метода array.reshape(shape).

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

Более подробно о том, как создавать массивы в NumPy , см. документацию.

Для получения элементов матрицы можно использовать несколько способов. Рассмотрим самые простые из них.

Для удобства напомним, как выглядит матрица d:

Элемент на пересечении строки i и столбца j можно получить с помощью выражения array[i, j].

Обратите внимание: строки и столбцы нумеруются с нуля!

Из матрицы можно получать целые строки или столбцы с помощью выражений array[i, :] или array[:, j] соответственно:

Еще один способ получения элементов — с помощью выражения array[list1, list2], где list1, list2 — некоторые списки целых чисел. При такой адресации одновременно просматриваются оба списка и возвращаются элементы матрицы с соответствующими координатами. Следующий пример более понятно объясняет механизм работы такого индексирования:

Примеры использования слайсинга:

Более подробно о различных способах индексирования в массивах см. документацию.

Следующие два способа задания массива кажутся одинаковыми:

Однако, на самом деле, это задание одномерного массива (то есть вектора) и двумерного массива:

Обратите внимание: вектор (одномерный массив) и вектор-столбец или вектор-строка (двумерные массивы) являются различными объектами в NumPy , хотя математически задают один и тот же объект. В случае одномерного массива кортеж shape состоит из одного числа и имеет вид (n,), где n — длина вектора. В случае двумерных векторов в shape присутствует еще одна размерность, равная единице.

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

Все элементы в массиве numpy принадлежат одному типу. В этом плане массивы ближе к C, чем к привычным вам листам питона. Numpy имеет множество встренных типов, подходящих для решения большинства задач.

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

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

Пусть матрицы A и B таковы, что A \in \mathbb^ и B \in \mathbb^ . Произведением матриц A и B называется матрица C, такая что c_ = \sum_^ a_b_ , где c_ — элемент матрицы C, стоящий на пересечении строки с номером i и столбца с номером j.

В NumPy произведение матриц вычисляется с помощью функции numpy.dot(a, b, . ) или с помощью метода array1.dot(array2), где array1 и array2 — перемножаемые матрицы.

Матрицы в NumPy можно умножать и на векторы:

Обратите внимание: операция * производит над матрицами покоординатное умножение, а не матричное!

Более подробно о матричном умножении в NumPy см. документацию.

Массивы можно Объединенять. Есть горизонтальное и вертикальное объединение.

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

Решите без использования циклов средставми NumPy (каждый пункт решается в 1-2 строчки)

1. Создайте вектор с элементами от 12 до 42
2. Создайте вектор из нулей длины 12, но его пятый елемент должен быть равен 1
3. Создайте матрицу (3, 3), заполненую от 0 до 8
4. Найдите все положительные числа в np.array([1,2,0,0,4,0])
5. Умножьте матрицу размерности (5, 3) на (3, 2)
6. Создайте матрицу (10, 10) так, чтобы на границе были 0, а внтури 1
7. Создайте рандомный вектор и отсортируйте его
8. Каков эквивалент функции enumerate для numpy массивов?
9. *Создайте рандомный вектор и выполните нормализацию столбцов (из каждого столбца вычесть среднее этого столбца, из каждого столбца вычесть sd этого столбца)
10. *Для заданного числа найдите ближайший к нему элемент в векторе
11. *Найдите N наибольших значений в векторе

Напоминание теории. Транспонированной матрицей A^ называется матрица, полученная из исходной матрицы A заменой строк на столбцы. Формально: элементы матрицы A^ определяются как a^_ = a_ , где a^_ — элемент матрицы A^ , стоящий на пересечении строки с номером i и столбца с номером j.

В NumPy транспонированная матрица вычисляется с помощью функции numpy.transpose() или с помощью метода array.T, где array — нужный двумерный массив.

См. более подробно о numpy.transpose() и array.T в NumPy .

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

Напоминание теории. Для квадратных матриц существует понятие определителя.

Пусть A — квадратная матрица. Определителем (или детерминантом) матрицы A \in \mathbb^ назовем число

где \alpha_<1>, \alpha_<2>, \dots, \alpha_ — перестановка чисел от 1 до n, N(\alpha_<1>, \alpha_<2>, \dots, \alpha_) — число инверсий в перестановке, суммирование ведется по всем возможным перестановкам длины n.

Не стоит расстраиваться, если это определение понятно не до конца — в дальнейшем в таком виде оно не понадобится.

Например, для матрицы размера 2 \times 2 получается:

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

В NumPy определитель матрицы вычисляется с помощью функции numpy.linalg.det(a), где a — исходная матрица.

Рассмотрим одно интересное свойство определителя. Пусть у нас есть параллелограмм с углами в точках (0, 0), (c,d), (a+c, b+d), (a, b) (углы даны в порядке обхода по часовой стрелке). Тогда площадь этого параллелограмма можно вычислить как модуль определителя матрицы \left( \begin a & c \\ b & d \end \right). Похожим образом можно выразить и объем параллелепипеда через определитель матрицы размера 3 \times 3.

Напоминание теории. Рангом матрицы A называется максимальное число линейно независимых строк (столбцов) этой матрицы.

В NumPy ранг матрицы вычисляется с помощью функции numpy.linalg.matrix_rank(M, tol=None), где M — матрица, tol — параметр, отвечающий за некоторую точность вычисления. В простом случае можно его не задавать, и функция сама определит подходящее значение этого параметра.

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

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

Напоминание теории. Системой линейных алгебраических уравнений называется система вида Ax = b, где A \in \mathbb^, x \in \mathbb^, b \in \mathbb^ . В случае квадратной невырожденной матрицы A решение системы единственно.

В NumPy решение такой системы можно найти с помощью функции numpy.linalg.solve(a, b), где первый аргумент — матрица A, второй — столбец b.

Убедимся, что вектор x действительно является решением системы:

Бывают случаи, когда решение системы не существует. Но хотелось бы все равно “решить” такую систему. Логичным кажется искать такой вектор x, который минимизирует выражение \left\Vert Ax - b\right\Vert^ — так мы приблизим выражение Ax к b.

В NumPy такое псевдорешение можно искать с помощью функции numpy.linalg.lstsq(a, b, . ), где первые два аргумента такие же, как и для функции numpy.linalg.solve(). Помимо решения функция возвращает еще три значения, которые нам сейчас не понадобятся.

Напоминание теории. Для квадратных невырожденных матриц определено понятие обратной матрицы.

Пусть A — квадратная невырожденная матрица. Матрица A^ называется обратной матрицей к A, если

где I — единичная матрица.

В NumPy обратные матрицы вычисляются с помощью функции numpy.linalg.inv(a), где a — исходная матрица.

Напоминание теории. Для квадратных матриц определены понятия собственного вектора и собственного числа.

Пусть A — квадратная матрица и A \in \mathbb^ . Собственным вектором матрицы A называется такой ненулевой вектор x \in \mathbb^ , что для некоторого \lambda \in \mathbb выполняется равенство Ax = \lambda x. При этом \lambda называется собственным числом матрицы A. Собственные числа и собственные векторы матрицы играют важную роль в теории линейной алгебры и ее практических приложениях.

В NumPy собственные числа и собственные векторы матрицы вычисляются с помощью функции numpy.linalg.eig(a), где a — исходная матрица. В качестве результата эта функция выдает одномерный массив w собственных чисел и двумерный массив v, в котором по столбцам записаны собственные вектора, так что вектор v[:, i] соотвествует собственному числу w[i].

Обратите внимание: у вещественной матрицы собственные значения или собственные векторы могут быть комплексными.

Вспомним некоторые нормы, которые можно ввести в пространстве \mathbb^ , и рассмотрим, с помощью каких библиотек и функций их можно вычислять в NumPy .

p-норма (норма Гёльдера) для вектора x = (x_<1>, \dots, x_) \in \mathbb^ вычисляется по формуле:

В частных случаях при: * p = 1 получаем \ell_ норму * p = 2 получаем \ell_ норму

Далее нам понабится модуль numpy.linalg , реализующий некоторые приложения линейной алгебры. Для вычисления различных норм мы используем функцию numpy.linalg.norm(x, ord=None, . ), где x — исходный вектор, ord — параметр, определяющий норму (мы рассмотрим два варианта его значений — 1 и 2). Импортируем эту функцию:

\ell_ норма (также известная как манхэттенское расстояние) для вектора x = (x_<1>, \dots, x_) \in \mathbb^ вычисляется по формуле:

Ей в функции numpy.linalg.norm(x, ord=None, . ) соответствует параметр ord=1.

\ell_ норма (также известная как евклидова норма) для вектора x = (x_<1>, \dots, x_) \in \mathbb^ вычисляется по формуле:

Ей в функции numpy.linalg.norm(x, ord=None, . ) соответствует параметр ord=2.

Более подробно о том, какие еще нормы (в том числе матричные) можно вычислить, см. документацию.

Для двух векторов x = (x_<1>, \dots, x_) \in \mathbb^ и y = (y_<1>, \dots, y_) \in \mathbb^ \ell_ и \ell_ раccтояния вычисляются по следующим формулам соответственно:

Скалярное произведение в пространстве \mathbb^ для двух векторов x = (x_<1>, \dots, x_) и y = (y_<1>, \dots, y_) определяется как:

Длиной вектора x = (x_<1>, \dots, x_) \in \mathbb^ называется квадратный корень из скалярного произведения, то есть длина равна евклидовой норме вектора:

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

где \alpha \in [0, \pi] — угол между векторами x и y.

Напоминание теории. Комплексными числами называются числа вида x + iy, где x и y — вещественные числа, а i — мнимая единица (величина, для которой выполняется равенство i^ <2>= -1). Множество всех комплексных чисел обозначается буквой \mathbb (подробнее про комплексные числа см. википедию).

В питоне комплескные числа можно задать следующим образом (j обозначает мнимую единицу):

С комплексными числами в питоне можно производить базовые арифметические операции так же, как и с вещественными числами:

Рассмотрим сложную математическую функцию на отрезке [1, 15]:

f(x) = sin(x / 5) * exp(x / 10) + 5 * exp(-x / 2)

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

Как известно, многочлен степени n (то есть w_0 + w_1 x + w_2 x^2 + \ldots + w_n x^n) однозначно определяется любыми n + 1 различными точками, через которые он проходит. Это значит, что его коэффициенты w_0, … w_n можно определить из следующей системы линейных уравнений:

где через x_1, . x_n, x_ обозначены точки, через которые проходит многочлен, а через f(x_1), . f(x_n), f(x_) — значения, которые он должен принимать в этих точках.

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