Métodos de interpolación en Python

Qué aprenderás

Esta página está pensada para quienes buscan una explicación clara de cómo interpolar puntos en Python usando Newton o Lagrange.

Nodos de Chebyshev vs nodos equiespaciados

La posición de los nodos puede importar tanto como la fórmula de interpolación. Con polinomios globales de grado alto, los nodos equiespaciados pueden crear oscilaciones grandes cerca de los extremos del intervalo. Los nodos de Chebyshev se concentran cerca de los extremos y suelen reducir ese comportamiento.

x_nodes = np.linspace(-1, 1, n)

k = np.arange(1, n + 1)
x_nodes = np.cos((2*k - 1) * np.pi / (2*n))

Interpolación de Newton en Python

El método de Newton escribe el polinomio usando coeficientes calculados con una tabla de diferencias divididas. Es muy útil para aprender la estructura del polinomio interpolador.

import numpy as np
from polynomial_interpolation import (
    evaluate_newton_polynomial,
    newton_coefficients,
)

x_nodes = np.array([-1.0, -0.5, 0.0, 0.5, 1.0])
y_nodes = 1 / (1 + 25 * x_nodes**2)

coefficients = newton_coefficients(x_nodes, y_nodes)
value = evaluate_newton_polynomial(coefficients, x_nodes, 0.25)

print(float(value))

Interpolación de Lagrange en Python

Con los mismos nodos, Lagrange y Newton representan el mismo polinomio interpolador. Lagrange suele ser la fórmula más directa para entender la teoría.

import numpy as np
from scipy.interpolate import lagrange

x_nodes = np.array([-1.0, -0.5, 0.0, 0.5, 1.0])
y_nodes = 1 / (1 + 25 * x_nodes**2)

polynomial = lagrange(x_nodes, y_nodes)
print(polynomial(0.25))

Por dentro de la implementación en Python

El repositorio mantiene el método de Newton como funciones de NumPy pequeñas y legibles. Estas son las piezas principales, tomadas directamente de polynomial_interpolation.py.

Construir la tabla de diferencias divididas

La tabla empieza con los valores y en la primera columna. Cada columna siguiente divide la diferencia de la columna anterior entre la distancia entre los x-nodos correspondientes. Los coeficientes de Newton son simplemente la primera fila de la tabla terminada.

def divided_difference_table(x, y):
    n = len(x)
    table = np.zeros((n, n))
    table[:, 0] = y

    for order in range(1, n):
        for row in range(n - order):
            numerator = table[row + 1, order - 1] - table[row, order - 1]
            denominator = x[row + order] - x[row]
            table[row, order] = numerator / denominator

    return table

# Los coeficientes de Newton son la primera fila de la tabla:
coefficients = divided_difference_table(x, y)[0, :]

Evaluar con multiplicación anidada (esquema de Horner)

En lugar de expandir el polinomio, el evaluador recorre los coeficientes hacia atrás y multiplica sobre la marcha. Es numéricamente estable, funciona sobre un único punto o sobre un array completo de NumPy, y mantiene el coste lineal en el número de nodos.

def evaluate_newton_polynomial(coefficients, x_nodes, x_eval):
    result = np.full_like(x_eval, coefficients[-1], dtype=float)

    for i in range(len(coefficients) - 2, -1, -1):
        result = result * (x_eval - x_nodes[i]) + coefficients[i]

    return result

Comparar cuatro métodos con los mismos nodos

El experimento construye el polinomio de Newton de este repositorio y los interpoladores de Lagrange, baricéntrico y spline cúbico de SciPy, y luego mide el error máximo y L2 frente a la función real en una malla densa.

from scipy.interpolate import (
    BarycentricInterpolator,
    InterpolatedUnivariateSpline,
    lagrange,
)

# Newton (implementado en este repositorio)
coefficients = newton_coefficients(x_nodes, y_nodes)
y_newton = evaluate_newton_polynomial(coefficients, x_nodes, x_grid)

# Lagrange, baricéntrico y spline cúbico (SciPy)
y_lagrange = lagrange(x_nodes, y_nodes)(x_grid)
y_bary = BarycentricInterpolator(x_nodes, y_nodes)(x_grid)
y_spline = InterpolatedUnivariateSpline(x_nodes, y_nodes, k=3)(x_grid)

# Error frente a la función real en una malla densa
max_error = np.max(np.abs(y_newton - y_true))
l2_error = np.sqrt(np.trapezoid((y_newton - y_true)**2, x_grid))

Demo interactiva de interpolación

Cambia la función, el tipo de nodos y el punto de evaluación. La gráfica muestra cómo la elección de nodos afecta al error.

Cómo ejecutar el repositorio

El archivo principal reproduce el experimento completo: Newton, Lagrange, método baricéntrico y spline cúbico.

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python polynomial_interpolation.py