Understanding Lagrange Interpolating Polynomials: Connecting the Dots
Introduction
In the vast realm of mathematics, interpolation plays a pivotal role. It allows us to fill in the gaps, connecting the dots, and making sense of data. One powerful tool for this purpose is the Lagrange Interpolating Polynomial. This polynomial, denoted as \(P(x)\), is a remarkable mathematical construct that efficiently captures and approximates a function based on a limited number of data points. In this blog, we will explore the Lagrange Interpolating Polynomial, its formula, and its significance in various fields.
Connecting the Dots
Imagine you have a set of data points \((x_1, y_1)\), \((x_2, y_2)\), …, \((x_n, y_n)\), and you want to find a polynomial that passes through all of them. The Lagrange Interpolating Polynomial provides a solution to this problem. It is a polynomial of degree less than or equal to \(n-1\) that seamlessly connects these points.
The Formula
Lagrange Interpolating Polynomial, \(P(x)\), is constructed using a combination of basis functions, one for each data point:
\[P(x) = \sum_{j=1}^{n} [y_j \cdot L_j(x)]\]Here, \(L_j(x)\) represents the Lagrange basis functions. Each \(L_j(x)\) is defined as:
\[L_j(x) = \prod_{k=1, k \neq j}^{n} \frac{(x - x_k)}{(x_j - x_k)}\]Explicitly, this can be written as:
\[P(x) = \frac{(x - x_2)(x - x_3) \ldots (x - x_n)}{(x_1 - x_2)(x_1 - x_3) \ldots (x_1 - x_n)} \cdot y_1 + \frac{(x - x_1)(x - x_3) \ldots (x - x_n)}{(x_2 - x_1)(x_2 - x_3) \ldots (x_2 - x_n)} \cdot y_2 + \ldots + \frac{(x - x_1)(x - x_2) \ldots (x - x_{n-1})}{(x_n - x_1)(x_n - x_2) \ldots (x_n - x_{n-1})} \cdot y_n\]Breaking It Down
The Lagrange Interpolating Polynomial may appear complex at first glance, but breaking it down into its components reveals its simplicity and elegance. Let’s delve into some key elements:
-
Basis Functions: Each term, \(L_j(x)\), represents a basis function for the \(j\)-th data point. These basis functions ensure that \(P(x)\) passes through the corresponding data point \((x_j, y_j)\). They are designed in such a way that when \(x\) equals \(x_j\), \(L_j(x)\) equals 1, and when \(x\) equals any other data point \(x_k\) (\(k \neq j\)), \(L_j(x)\) equals 0, ensuring the polynomial’s property.
-
Weights: The values \(y_j\) are the weights associated with each data point. They determine the influence of each data point on the polynomial. The weight \(y_j\) is multiplied by the corresponding basis function \(L_j(x)\) for each data point.
-
Normalization: The denominator in each term normalizes the basis functions, ensuring that when evaluated at a data point \(x_j\), the corresponding term equals \(y_j\).
Conclusion
The Lagrange Interpolating Polynomial is a versatile and powerful mathematical tool that connects the dots between data points, allowing us to approximate and interpolate functions with precision. Its formula, composed of basis functions and weights, ensures that the polynomial passes through the given data points. This concept finds applications in various fields, making it an essential tool for engineers, scientists, and mathematicians. So, the next time you need to connect the dots in your data, remember the Lagrange Interpolating Polynomial as your reliable mathematical friend.
Python Notebook
import sympy as sp
import numpy as np
import matplotlib.pyplot as plt
from IPython.display import Latex
def interpolate_lagrange(x_values, y_values):
# Define the symbolic variable
x = sp.symbols('x')
# Initialize the Lagrange polynomial
lagrange_poly = 0
# Calculate the Lagrange basis polynomials
for i in range(len(x_values)):
basis_poly = 1
for j in range(len(x_values)):
if i != j:
basis_poly *= (x - x_values[j]) / (x_values[i] - x_values[j])
lagrange_poly += y_values[i] * basis_poly
# Simplify the Lagrange polynomial
lagrange_poly
return lagrange_poly
def interpolate_and_plot(function_str, x_values):
# Create a lambda function from the string
if isinstance(function_str, str):
f = lambda x: eval(function_str)
# Define the interpolation points and function values
y_values = [f(x) for x in x_values]
else:
y_values = function_str
# Perform Lagrange interpolation
lagrange_poly = interpolate_lagrange(x_values, y_values)
# Create a range of x values for plotting
x_range = np.linspace(min(x_values), max(x_values), 400) # Adjust the range as needed
# Evaluate the interpolating polynomial at the x_range
y_interpolated = [lagrange_poly.subs('x', xi).evalf() for xi in x_range]
# Convert the Lagrange polynomial to LaTeX format
latex_formula = sp.latex(lagrange_poly)
# Create a plot of the original function
if isinstance(function_str, str):
label = f'f(x) = {function_str}'
plt.plot(x_range, f(x_range), label=label, color='blue', linewidth=3)
# Create a scatter plot of the interpolation points
plt.scatter(x_values, y_values, label='Interpolation Points', color='red')
# Create a plot of the interpolating polynomial
plt.plot(x_range, y_interpolated, label='Interpolating Polynomial', color='orange', linestyle='--', linewidth=2)
title_text = f'Lagrange Polynomial:\n${latex_formula}$'
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
# Show the plot
plt.grid(True)
plt.show()
print("Lagrange Polynomial:")
display(Latex(latex_formula))
print("Polynomial:")
display(Latex(sp.latex(sp.simplify(lagrange_poly))))
return lagrange_poly
function = "np.sqrt(1 + x**2)"
x_values = [0, 1/3, 1/2, 1]
interpolate_and_plot(function, x_values)
Lagrange Polynomial:
Polynomial:
function = [6,5,12]
x_values = [9,3,1]
lagrange_poly=interpolate_and_plot(function, x_values)
x_value = 10
y_value = lagrange_poly.subs('x', x_value)
print(f'f({x_value}) = {y_value}')
Lagrange Polynomial:
Polynomial:
f(10) = 75/8
function = [10,4,4,7]
x_values = [1,2,3,5]
lagrange_poly=interpolate_and_plot(function, x_values)
x_value = 7
y_value = lagrange_poly.subs('x', x_value)
print(f'f({x_value}) = {y_value}')
Lagrange Polynomial:
Polynomial:
f(7) = -11
function = [12,13,14,15]
x_values = [5,6,7,8]
lagrange_poly=interpolate_and_plot(function, x_values)
x_value = 10
y_value = lagrange_poly.subs('x', x_value)
print(f'f({x_value}) = {y_value}')
Lagrange Polynomial:
Polynomial:
f(10) = 17
function = 'np.sin(3*x)'
x_values = np.arange(1, 2.2, 1.2/5)
lagrange_poly=interpolate_and_plot(function, x_values)
x_value = 1.5
y_value = lagrange_poly.subs('x', x_value)
print(f'f({x_value}) = {y_value}')
Lagrange Polynomial:
Polynomial:
f(1.5) = -0.977358438732647
function = 'np.sqrt(1+x**2)'
x_values = np.arange(0, 1, 1/3)
lagrange_poly=interpolate_and_plot(function, x_values)
x_value = x_values[2]
y_value = lagrange_poly.subs('x', x_value)
print(f'f({x_value}) = {y_value}')
Lagrange Polynomial:
Polynomial:
f(0.6666666666666666) = 1.20185042515466
