La interpolación lineal es una técnica fundamental en análisis numérico que permite estimar valores intermedios dentro de un conjunto de datos discretos. A diferencia de los métodos más complejos (splines, interpolación polinómica de alto grado), la lineal es simple, rápida y, en muchos casos, suficientemente precisa.

En este artículo encontrarás:

• Fundamentos matemáticos de la interpolación lineal.
• Implementación paso a paso en Python (sin dependencias externas y usando numpy/scipy).
• Ejemplos reales: series temporales, calibración de sensores y gráficos interactivos.
• Comparativa con otros algoritmos de interpolación.
• Buenas prácticas, optimización y troubleshooting.

1. Fundamento Matemático

Dados dos puntos conocidos \((x_0, y_0)\) y \((x_1, y_1)\) donde \(x_0 \neq x_1\), el valor estimado \(y\) para cualquier \(x\) entre ellos se calcula mediante:

y = y_0 + (y_1 - y_0) * \frac{x - x_0}{x_1 - x_0}

Esta ecuación representa la recta que pasa por los dos puntos y garantiza continuidad en \(C^0\) (valor) pero no en la derivada.

2. Implementación en Python

Hay tres enfoques habituales:

1. Implementación manual (solo math).
2. Uso de numpy.interp (rápido y vectorizado).
3. Uso de scipy.interpolate.interp1d para mayor flexibilidad (permite extrapolación, diferentes estilos).

2.1 Código “desde cero”

def linear_interp(x, xp, fp):
    """Interpolación lineal sin librerías externas.
    Args:
        x (float or list/np.ndarray): Punto(s) a interpolar.
        xp (list/np.ndarray): Coordenadas x de los datos conocidos (ordenadas).
        fp (list/np.ndarray): Coordenadas y correspondientes.
    Returns:
        float or np.ndarray: Valor(es) interpolado(s).
    """
    import bisect
    import numpy as np
    if np.isscalar(x):
        x = [x]
    result = []
    for xv in x:
        # Ubicar el intervalo [xp[i], xp[i+1]] que contiene xv
        i = bisect.bisect_left(xp, xv) - 1
        if i < 0:
            i = 0
        if i >= len(xp) - 1:
            i = len(xp) - 2
        x0, x1 = xp[i], xp[i+1]
        y0, y1 = fp[i], fp[i+1]
        # Fórmula de interpolación lineal
        y = y0 + (y1 - y0) * (xv - x0) / (x1 - x0)
        result.append(y)
    return np.array(result) if len(result) > 1 else result[0]

2.2 Con numpy.interp

import numpy as np
xp = np.array([0, 2, 4, 6])
fp = np.array([0, 1, 0, 1])
x_new = np.linspace(0, 6, 13)  # 0,0.5,…,6
y_new = np.interp(x_new, xp, fp)
print(y_new)

2.3 Con scipy.interpolate.interp1d

from scipy.interpolate import interp1d
import numpy as np
import matplotlib.pyplot as plt
xp = np.array([0, 1, 2, 3, 4])
fp = np.sin(xp)
# Crear la función interpoladora
f = interp1d(xp, fp, kind='linear', fill_value='extrapolate')
x_fine = np.linspace(-1, 5, 200)
y_fine = f(x_fine)
plt.figure(figsize=(8,4))
plt.plot(xp, fp, 'o', label='Datos originales')
plt.plot(x_fine, y_fine, '-', label='Interpolación lineal')
plt.legend(); plt.title('Interpolación lineal con SciPy'); plt.show()

3. Casos de Uso del Mundo Real

# Tabla de calibración (°C → ADC)
cal_temp = np.array([0, 10, 20, 30, 40])
cal_adc  = np.array([100, 250, 400, 560, 720])
def temp_from_adc(adc):
    return np.interp(adc, cal_adc, cal_temp)

import pandas as pd
# Simular un DataFrame con timestamps faltantes
rng = pd.date_range('2024-01-01', periods=10, freq='T')
prices = pd.Series([100, np.nan, 101, np.nan, np.nan, 103, 104, np.nan, 105, 106], index=rng)
# Rellenar con interpolación lineal
prices_filled = prices.interpolate(method='linear')
print(prices_filled)

4. Comparativa con Otros Algoritmos de Interpolación

5. Buenas Prácticas, Optimización y Seguridad

• Ordenar los puntos antes de interpolar (\(x_i\) debe ser monótono).
• Validar rangos: si el punto a interpolar está fuera del dominio, decidir entre extrapolación controlada o lanzar excepción.
• Vectorizar con NumPy para grandes volúmenes (evita bucles Python).
• Precaución con datos de alta frecuencia: la interpolación lineal puede introducir artefactos de aliasing; considere un filtro previo.
• Seguridad en entornos críticos (p.ej., control de procesos): combine la interpolación con límites de tolerancia y alertas de desviación.

5.1 Profiling rápido

import numpy as np, time
xp = np.sort(np.random.rand(1_000_000))
fp = np.sin(xp)
xi = np.linspace(0,1,1_000_000)
start = time.perf_counter()
yi = np.interp(xi, xp, fp)
print('Tiempo np.interp:', time.perf_counter()-start)

En un CPU moderno, interpolar un millón de puntos con np.interp suele tardar

6. Conclusión

La interpolación lineal sigue siendo una herramienta indispensable por su simplicidad, velocidad y bajo consumo de recursos. Cuando la precisión requerida es moderada y la arquitectura del proyecto impone limitaciones de memoria o tiempo, elegir este método es la decisión más sensata. Sin embargo, es crucial reconocer sus limitaciones (continuidad de la derivada, posible sub‑/sobre‑estimación) y, en caso de requerir mayor suavidad, migrar a splines o métodos basados en kriging.