Splines cúbicos

01 · Del modelo global al local

Una curva compuesta, no un polinomio enorme

Los métodos de Lagrange y Newton construyen un único polinomio que atraviesa todos los datos. Si hay muchos nodos, su grado crece y una modificación local puede cambiar la curva en todo el intervalo.

Un spline cúbico adopta otra estrategia: entre cada par de nodos consecutivos utiliza un polinomio de grado a lo sumo tres.

Las piezas no se eligen de manera independiente. Se imponen condiciones en sus uniones para que el resultado se comporte como una sola curva suave.

02 · Qué debe cumplir

Interpolación y suavidad C²

Dados nodos ordenados x₀<x₁<…<xₙ y valores yᵢ, cada tramo debe interpolar sus extremos:

En cada nodo interior xᵢ, las dos piezas vecinas deben coincidir también en pendiente y curvatura:

Decimos que S∈C²: la función, su primera derivada y su segunda derivada son continuas. La tercera derivada puede saltar al pasar de un tramo a otro.

03 · Grado mínimo útil

¿Por qué polinomios cúbicos?

Una recta interpola dos extremos, pero su pendiente constante produce esquinas en los nodos. Una cuadrática admite curvatura, aunque no ofrece suficientes grados de libertad para coordinar cómodamente valor, pendiente y segunda derivada en todos los empalmes.

Un cúbico tiene cuatro coeficientes:

Estos cuatro parámetros permiten interpolar los extremos y ajustar las derivadas necesarias. El uso de x−xᵢ como variable local simplifica las fórmulas y reduce magnitudes intermedias.

04 · Unicidad

Por qué faltan dos condiciones

Hay n tramos y cuatro coeficientes por tramo: en total, 4n incógnitas. Las restricciones aportan:

• 2n ecuaciones para interpolar ambos extremos de cada tramo;
• n−1 ecuaciones de continuidad de la primera derivada;
• n−1 ecuaciones de continuidad de la segunda derivada.

La suma es 4n−2. Todavía hacen falta dos condiciones de frontera para obtener una solución única. La forma de elegirlas define el tipo de spline.

05 · Cerrar el sistema

Condiciones de frontera

En este tema construiremos el spline natural. Es sencillo, frecuente y permite ver con claridad el sistema numérico central.

06 · Incógnitas convenientes

Resolver primero las curvaturas nodales

Definimos la longitud de cada intervalo y la segunda derivada en cada nodo:

En un spline natural, M₀=Mₙ=0. Para cada nodo interior, la continuidad de la primera derivada conduce a:

El lado derecho mide cuánto cambia la pendiente entre dos intervalos vecinos. Si los datos son colineales, ese cambio es cero y todas las curvaturas resultan nulas.

07 · Estructura numérica

Un sistema tridiagonal

Cada ecuación interior contiene solo Mᵢ₋₁, Mᵢ y Mᵢ₊₁. La matriz tiene elementos únicamente en tres diagonales:

Un sistema denso de tamaño n+1 costaría en general O(n³). El algoritmo de Thomas aprovecha esta estructura y necesita solo O(n) tiempo y memoria.

08 · De curvaturas a tramos

Fórmula de cada pieza

Una vez calculados Mᵢ y Mᵢ₊₁, la pieza sobre [xᵢ,xᵢ₊₁] es:

También podemos guardar coeficientes locales aᵢ,bᵢ,cᵢ,dᵢ:

Entonces evaluamos con t=x−xᵢ mediante la forma anidada aᵢ+t(bᵢ+t(cᵢ+tdᵢ)).

09 · Cálculo manual

Tres puntos y dos cúbicas

Consideremos (0,0), (1,1) y (2,0). Tenemos h₀=h₁=1 y, por ser natural, M₀=M₂=0. La única ecuación interior es:

Al sustituir en las fórmulas obtenemos:

En x=1, ambas piezas valen 1, sus pendientes valen 0 y sus segundas derivadas valen −3. No hay salto, esquina ni cambio brusco de curvatura.

10 · Preprocesamiento

Construir un spline natural en JavaScript

La eliminación hacia adelante y la sustitución hacia atrás resuelven directamente el sistema tridiagonal. El resultado almacena un cúbico local por intervalo:

function splineNatural(puntos) {
  if (puntos.length < 2) throw new Error("Se requieren dos puntos");
  const datos = puntos.map(([x, y]) => [Number(x), Number(y)]);
  for (const [x, y] of datos) {
    if (!Number.isFinite(x) || !Number.isFinite(y)) {
      throw new Error("Todos los datos deben ser finitos");
    }
  }
  datos.sort((p, q) => p[0] - q[0]);

  const n = datos.length - 1;
  const x = datos.map(p => p[0]);
  const y = datos.map(p => p[1]);
  const h = Array(n);
  for (let i = 0; i < n; i++) {
    h[i] = x[i + 1] - x[i];
    if (h[i] === 0) throw new Error("Hay nodos duplicados");
  }

  const inferior = Array(n + 1).fill(0);
  const diagonal = Array(n + 1).fill(1);
  const superior = Array(n + 1).fill(0);
  const rhs = Array(n + 1).fill(0);

  for (let i = 1; i < n; i++) {
    inferior[i] = h[i - 1];
    diagonal[i] = 2 * (h[i - 1] + h[i]);
    superior[i] = h[i];
    rhs[i] = 6 * ((y[i + 1] - y[i]) / h[i]
      - (y[i] - y[i - 1]) / h[i - 1]);
  }

  for (let i = 1; i <= n; i++) {
    const factor = inferior[i] / diagonal[i - 1];
    diagonal[i] -= factor * superior[i - 1];
    rhs[i] -= factor * rhs[i - 1];
  }

  const M = Array(n + 1).fill(0);
  M[n] = rhs[n] / diagonal[n];
  for (let i = n - 1; i >= 0; i--) {
    M[i] = (rhs[i] - superior[i] * M[i + 1]) / diagonal[i];
  }

  const tramos = Array.from({ length: n }, (_, i) => ({
    x: x[i],
    a: y[i],
    b: (y[i + 1] - y[i]) / h[i] - h[i] * (2 * M[i] + M[i + 1]) / 6,
    c: M[i] / 2,
    d: (M[i + 1] - M[i]) / (6 * h[i])
  }));
  return { nodos: x, tramos, curvaturas: M };
}

const modelo = splineNatural([[0, 0], [1, 1], [2, 0]]);
console.log(modelo.curvaturas); // [0, -3, 0]

Ordenar copias de los datos hace que la función acepte entradas desordenadas sin modificar el arreglo original. Después de ordenar, un intervalo nulo revela nodos duplicados.

11 · Consulta eficiente

Localizar el tramo y aplicar Horner

Para evaluar, primero localizamos el intervalo mediante búsqueda binaria. Eso cuesta O(log n); evaluar el cúbico cuesta O(1).

function evaluarSpline(modelo, valorX) {
  const { nodos, tramos } = modelo;
  if (valorX < nodos[0] || valorX > nodos.at(-1)) {
    throw new RangeError("La consulta está fuera del intervalo");
  }

  let izquierda = 0;
  let derecha = nodos.length - 2;
  while (izquierda <= derecha) {
    const medio = Math.floor((izquierda + derecha) / 2);
    if (valorX < nodos[medio]) derecha = medio - 1;
    else if (valorX > nodos[medio + 1]) izquierda = medio + 1;
    else {
      const { x, a, b, c, d } = tramos[medio];
      const t = valorX - x;
      return a + t * (b + t * (c + t * d));
    }
  }
}

const spline = splineNatural([[0, 0], [1, 1], [2, 0]]);
console.log(evaluarSpline(spline, 0.5)); // 0.6875
console.log(evaluarSpline(spline, 1.5)); // 0.6875

En x=xₙ, la búsqueda selecciona el último tramo. La función rechaza la extrapolación deliberadamente: extender la última cúbica es posible, pero no conserva garantías fuera de los datos.

12 · Costos y actualizaciones

Qué ganamos y qué no

Agregar o modificar un nodo puede alterar varias curvaturas porque el sistema está conectado. “Por tramos” no significa que cada segmento sea independiente; significa que la representación y el comportamiento son mucho más locales.

13 · Precisión y forma

Error, ruido y preservación de forma

Para una función suficientemente suave y una malla con paso máximo h, el error del spline cúbico suele decrecer como O(h⁴) en el interior. Reducir a la mitad el espaciamiento puede disminuir el error aproximadamente por un factor de dieciséis.

Sin embargo, interpolar significa atravesar cada dato. Si las observaciones contienen ruido, el spline también lo seguirá. En ese caso puede convenir un spline de suavizado o el ajuste por mínimos cuadrados del próximo tema.

14 · Exploración interactiva

Laboratorio: spline local frente a polinomio global

Elegí un conjunto de datos y la cantidad de nodos. La curva turquesa es el spline natural; la dorada es el polinomio global de Newton construido con los mismos puntos.

Preguntas para explorar

1. En Runge, aumentá los nodos y compará ambas curvas cerca de x=±1.
2. Mové la consulta exactamente sobre un nodo: ambos errores deben acercarse a cero.
3. Observá que el spline pasa por cada muestra sin adquirir un grado global mayor.
4. Probá el pico asimétrico y buscá pequeños excesos entre nodos.

15 · Comprensión

Confusiones frecuentes

16 · Práctica guiada

Ejercicios

Ejercicio 1: cantidad de tramos

¿Cuántos polinomios cúbicos se necesitan para interpolar seis nodos distintos?

Ejercicio 2: condición natural

¿Qué valores toman M₀ y Mₙ en un spline natural?

Ejercicio 3: datos lineales

Si todos los puntos pertenecen a una misma recta, ¿qué produce el spline natural?

Ejercicio 4: ejemplo manual

Para los puntos (0,0), (1,1) y (2,0), evaluá el spline natural en x=0.5.

Ejercicio 5: derivadas

Extendé el evaluador para devolver también S′(x) y S″(x).

function evaluarTramoConDerivadas(tramo, valorX) {
  const { x, a, b, c, d } = tramo;
  const t = valorX - x;
  return {
    valor: a + t * (b + t * (c + t * d)),
    primera: b + t * (2 * c + 3 * d * t),
    segunda: 2 * c + 6 * d * t
  };
}

console.log(evaluarTramoConDerivadas(
  { x: 0, a: 0, b: 1.5, c: 0, d: -0.5 }, 0.5
));
// { valor: 0.6875, primera: 1.125, segunda: -1.5 }

17 · Síntesis

Ideas para recordar

En el próximo tema dejaremos de exigir que la curva atraviese todos los datos y estudiaremos el ajuste por mínimos cuadrados, apropiado para mediciones con ruido.