Polinomio de Lagrange

01 · Otra representación

El mismo polinomio sin resolver Vandermonde

En el tema anterior construimos un polinomio en la base 1,x,x²,… y obtuvimos sus coeficientes mediante un sistema de Vandermonde. Lagrange propone una base adaptada a los nodos, de modo que las condiciones de interpolación quedan incorporadas desde el comienzo.

Cada polinomio Lᵢ activa el valor yᵢ en su nodo y lo desactiva en todos los demás.

02 · Polinomios cardinales

Construir una base Lᵢ(x)

Para nodos distintos x₀,…,xₙ, definimos:

El producto contiene un factor por cada nodo diferente de xᵢ. Los denominadores son constantes y no se anulan porque los nodos son distintos.

Cada Lᵢ tiene grado n y depende únicamente de las posiciones de los nodos, no de los valores yᵢ.

03 · Mecanismo

Uno en su nodo, cero en los demás

Al evaluar Lᵢ en un nodo xₖ ocurren dos casos:

Si k=i

Cada factor es (xᵢ−xⱼ)/(xᵢ−xⱼ)=1; por lo tanto, Lᵢ(xᵢ)=1.

Si k≠i

El producto incluye (xₖ−xₖ)=0; por lo tanto, Lᵢ(xₖ)=0.

Esta propiedad se resume con la delta de Kronecker:

Entonces, al evaluar la suma en xₖ, todos los términos desaparecen excepto yₖLₖ(xₖ)=yₖ.

04 · Construcción completa

Sumar las contribuciones

El polinomio interpolante de Lagrange es:

Cada término yᵢLᵢ(x) es la contribución del dato (xᵢ,yᵢ). Fuera de los nodos, varias bases pueden ser positivas o negativas y sus aportes se combinan.

05 · Dos puntos

Lagrange recupera la interpolación lineal

Con dos nodos, las bases son:

Por lo tanto:

Al reorganizarla obtenemos exactamente la fórmula lineal (1−t)y₀+ty₁. Lagrange es una generalización natural de las ponderaciones lineales.

06 · Ejemplo manual

Interpolar tres puntos

Usamos (0,1), (1,2) y (2,5). Las bases son:

El polinomio queda:

Al simplificar, p₂(x)=1+x². Para x=1.5:

07 · Propiedades

Partición de la unidad y reproducción

Las bases satisfacen:

La razón es que la suma interpola el valor constante 1 en todos los nodos, y el único polinomio de grado máximo n que reproduce esos datos es la constante.

Consecuencias:

• si todos los yᵢ son iguales a c, entonces p(x)=c;
• una suma de bases distinta de uno revela error de implementación o redondeo importante;
• las ponderaciones no siempre están entre cero y uno, especialmente fuera del intervalo o con muchos nodos.

08 · Fórmula directa

Evaluar Lagrange en JavaScript

function lagrangeDirecto(puntos, x) {
  if (puntos.length === 0) throw new Error("Faltan puntos");
  let resultado = 0;

  for (let i = 0; i < puntos.length; i++) {
    const [xi, yi] = puntos[i];
    let base = 1;
    for (let j = 0; j < puntos.length; j++) {
      if (j === i) continue;
      const xj = puntos[j][0];
      if (xi === xj) throw new Error("Los nodos deben ser distintos");
      base *= (x - xj) / (xi - xj);
    }
    resultado += yi * base;
  }
  return resultado;
}

const puntos = [[0, 1], [1, 2], [2, 5]];
console.log(lagrangeDirecto(puntos, 1.5)); // 3.25

El código sigue literalmente la definición. Resulta claro para aprender y para conjuntos pequeños, pero recalcula los mismos denominadores en cada consulta.

09 · Trabajo computacional

Construcción implícita y costo de evaluación

Si evaluamos el mismo interpolante muchas veces, podemos precomputar pesos que dependen únicamente de los nodos y utilizar la forma baricéntrica.

10 · Forma recomendada

Interpolación baricéntrica de Lagrange

Definimos los pesos:

Para un punto que no coincide con un nodo:

Los pesos requieren O(n²) una sola vez. Luego cada evaluación cuesta O(n). Además, esta forma evita expandir el polinomio a coeficientes monomiales y suele comportarse mejor numéricamente.

11 · Precalcular y reutilizar

Interpolador baricéntrico en JavaScript

function crearLagrangeBaricentrico(puntos) {
  const datos = puntos.map(([x, y]) => [x, y]);
  const pesos = datos.map(([xi], i) => {
    let producto = 1;
    for (let j = 0; j < datos.length; j++) {
      if (j === i) continue;
      const diferencia = xi - datos[j][0];
      if (diferencia === 0) throw new Error("Nodo duplicado");
      producto *= diferencia;
    }
    return 1 / producto;
  });

  return x => {
    let numerador = 0;
    let denominador = 0;
    for (let i = 0; i < datos.length; i++) {
      const [xi, yi] = datos[i];
      if (x === xi) return yi;
      const termino = pesos[i] / (x - xi);
      numerador += termino * yi;
      denominador += termino;
    }
    return numerador / denominador;
  };
}

const p = crearLagrangeBaricentrico([[0, 1], [1, 2], [2, 5]]);
console.log(p(1.5), p(2)); // 3.25, 5

Para nodos numerosos o extremos, bibliotecas especializadas calculan y escalan los pesos cuidadosamente para evitar desbordamiento y subdesbordamiento.

12 · Precisión

El error depende de la función y de los nodos

Lagrange representa el mismo polinomio del tema anterior, por lo que conserva el mismo resto:

Cambiar de Vandermonde a Lagrange no elimina el fenómeno de Runge: una representación más estable reduce errores computacionales, pero no corrige las oscilaciones matemáticas del polinomio elegido.

Para controlar el error podemos:

• elegir mejor los nodos, por ejemplo con distribución de Chebyshev;
• usar menor grado en subintervalos;
• aplicar splines cuando se requiere suavidad local;
• evitar extrapolaciones lejanas;
• comparar con datos de validación.

13 · Representaciones

Vandermonde, Lagrange y Newton

En aritmética exacta todas producen el mismo polinomio. En coma flotante, el procedimiento y la representación influyen en la precisión obtenida.

14 · Exploración interactiva

Laboratorio: observar una base y su contribución

Elegí una función, la cantidad de nodos, una base y un valor de consulta. La curva dorada representa Lᵢ(x) y la turquesa el polinomio interpolante.

Preguntas para explorar

1. Mové la consulta sobre distintos nodos y observá cuándo la base vale cero o uno.
2. Para la cuadrática, probá tres o más nodos: el error debería ser casi nulo.
3. Con Runge y nueve nodos, observá el polinomio cerca de los extremos.
4. Cambiá la base seleccionada: el polinomio total no cambia, pero sí la contribución mostrada.

15 · Comprensión

Confusiones frecuentes

16 · Práctica guiada

Ejercicios

Ejercicio 1: construir una base

Para nodos 0,1,3, escribí L₁(x).

Ejercicio 2: propiedad cardinal

Evaluá la base anterior en x=0, x=1 y x=3.

Ejercicio 3: contribuciones

En el ejemplo de tres puntos, sumá los aportes en x=1.5.

Ejercicio 4: costo

¿Cuál es el costo de cien evaluaciones después de precalcular pesos baricéntricos para n+1 nodos?

Ejercicio 5: verificar las bases

Implementá una función que evalúe una sola base de Lagrange.

function baseLagrange(nodos, i, x) {
  if (i < 0 || i >= nodos.length) throw new Error("Índice inválido");
  let valor = 1;
  for (let j = 0; j < nodos.length; j++) {
    if (j === i) continue;
    if (nodos[i] === nodos[j]) throw new Error("Nodo duplicado");
    valor *= (x - nodos[j]) / (nodos[i] - nodos[j]);
  }
  return valor;
}

console.log([0, 1, 3].map(x => baseLagrange([0, 1, 3], 1, x)));
// [0, 1, 0]

17 · Síntesis

Ideas para recordar

En el próximo tema construiremos el interpolante mediante diferencias divididas de Newton y aprenderemos a incorporar nuevos nodos de forma incremental.