Reglas de Simpson

01 · Más curvatura por panel

De segmentos a parábolas

El trapecio aproxima la función mediante una recta entre dos nodos. Simpson utiliza tres nodos igualmente espaciados y construye un polinomio cuadrático que sigue también la curvatura local.

Sobre dos subintervalos de ancho h, usamos x₀, x₁=x₀+h y x₂=x₀+2h. Integramos exactamente la parábola interpolante.

02 · Regla 1/3 simple

Los pesos 1, 4, 1

En coordenadas locales centradas, los nodos están en −h,0,h. Integramos las tres bases de Lagrange y obtenemos:

Como el panel completo mide x₂−x₀=2h, también puede escribirse:

El punto central recibe cuatro veces el peso de cada extremo. Esta distribución surge de integrar la parábola, no de un promedio arbitrario.

03 · Una cancelación adicional

Exacta también para cúbicas

La interpolación empleada tiene grado dos, pero la simetría del panel cancela el aporte del término cúbico impar. Por eso Simpson 1/3 integra exactamente todo polinomio de grado menor o igual que tres.

El primer término que produce error involucra la cuarta derivada. Para un panel simple:

Si la función es un polinomio cúbico, f⁽⁴⁾=0 y la regla es exacta.

04 · Paneles consecutivos

Simpson 1/3 compuesto

Dividimos [a,b] en un número par de subintervalos uniformes, h=(b−a)/n. Cada panel consume dos subintervalos:

Los pesos siguen el patrón:

Los nodos pares interiores son compartidos por dos paneles y acumulan peso dos. Los nodos impares son los centros de sus paneles y pesan cuatro.

05 · Condición estructural

Por qué n debe ser par

Un panel 1/3 necesita exactamente dos subintervalos. Para cubrir toda la malla sin dejar uno suelto, n debe ser divisible por dos.

Aplicar mecánicamente el patrón de pesos con n impar no define Simpson compuesto y produce un resultado sin la derivación ni el orden esperados.

06 · Cálculo manual

Integrar x⁴ entre 0 y 2

Tomamos n=4 y h=0.5. Los valores son [0,0.0625,1,5.0625,16].

La integral exacta es 2⁵/5=6.4. El error es aproximadamente 0.016667. Simpson ya no es exacta porque la cuarta derivada de x⁴ no se anula.

07 · Código reutilizable

Simpson 1/3 compuesto en JavaScript

function simpson13(f, a, b, n) {
  if (!Number.isInteger(n) || n < 2 || n % 2 !== 0) {
    throw new Error("n debe ser un entero par positivo");
  }
  const h = (b - a) / n;
  let suma = f(a) + f(b);

  for (let i = 1; i < n; i++) {
    suma += (i % 2 === 0 ? 2 : 4) * f(a + i * h);
  }
  return h * suma / 3;
}

console.log(simpson13(x => x ** 4, 0, 2, 4)); // 6.416666...
console.log(simpson13(x => x ** 3, 0, 2, 4)); // 4, exacta

La evaluación de cada nodo se realiza una sola vez. Los límites invertidos funcionan porque h conserva el signo de b−a.

08 · Precisión global

Error de cuarto orden

Para una función con cuarta derivada continua, el error compuesto es:

Si M₄≥max|f⁽⁴⁾(x)|:

Simpson compuesto es O(h⁴). Al duplicar n, el error de truncamiento suele dividirse aproximadamente por 2⁴=16.

El mayor orden no garantiza una ventaja si la función carece de suavidad, la malla no resuelve sus variaciones o domina el redondeo.

09 · Tres subintervalos por panel

Regla de Simpson 3/8

Interpolamos cuatro nodos igualmente espaciados mediante un polinomio cúbico. Sobre tres subintervalos de ancho h:

También tiene grado de exactitud tres y error de orden cuatro. Su versión simple necesita cuatro evaluaciones, una más que Simpson 1/3.

La regla 3/8 es especialmente útil para cubrir un bloque de tres subintervalos cuando una partición no puede agruparse completamente en pares.

10 · Pesos periódicos

Simpson 3/8 compuesto

Ahora n debe ser múltiplo de tres:

function simpson38(f, a, b, n) {
  if (!Number.isInteger(n) || n < 3 || n % 3 !== 0) {
    throw new Error("n debe ser múltiplo positivo de 3");
  }
  const h = (b - a) / n;
  let suma = f(a) + f(b);

  for (let i = 1; i < n; i++) {
    suma += (i % 3 === 0 ? 2 : 3) * f(a + i * h);
  }
  return 3 * h * suma / 8;
}

console.log(simpson38(x => x ** 3, 0, 3, 3)); // 20.25
console.log(3 ** 4 / 4);                       // 20.25

11 · Cubrir cualquier malla razonable

Combinar 1/3 y 3/8

Con una cantidad par usamos Simpson 1/3 en todo el intervalo. Si n es impar y al menos tres, aplicamos 1/3 en los primeros n−3 subintervalos y 3/8 en los últimos tres.

function simpson13(f, a, b, n) {
  const h = (b - a) / n;
  let suma = f(a) + f(b);
  for (let i = 1; i < n; i++) suma += (i % 2 ? 4 : 2) * f(a + i * h);
  return h * suma / 3;
}

function simpson38(f, a, b, n) {
  const h = (b - a) / n;
  let suma = f(a) + f(b);
  for (let i = 1; i < n; i++) suma += (i % 3 ? 3 : 2) * f(a + i * h);
  return 3 * h * suma / 8;
}

function simpsonFlexible(f, a, b, n) {
  if (!Number.isInteger(n) || n < 2) throw new Error("n debe ser al menos 2");
  if (n % 2 === 0) return simpson13(f, a, b, n);

  const h = (b - a) / n;
  const corte = b - 3 * h;
  let total = 0;
  if (n > 3) total += simpson13(f, a, corte, n - 3);
  total += simpson38(f, corte, b, 3);
  return total;
}

console.log(simpsonFlexible(Math.sin, 0, Math.PI, 7));

Las funciones auxiliares del ejemplo omiten validaciones repetidas para destacar la estrategia de composición; una biblioteca pública debería conservarlas.

12 · Requisitos de los datos

Muestras uniformes y completas

Los pesos clásicos de Simpson suponen nodos igualmente espaciados. Antes de integrar una tabla debemos verificar:

• que las abscisas estén estrictamente ordenadas;
• que las separaciones sean iguales dentro de una tolerancia;
• que 1/3 reciba un número par de intervalos;
• que 3/8 reciba un múltiplo de tres.

Con nodos no uniformes es posible integrar el polinomio interpolante general, pero los pesos 1,4,1 y 1,3,3,1 dejan de ser válidos. El trapecio no uniforme suele ser una alternativa segura y simple.

13 · Refinar y comparar

Estimación del error con n y 2n

Si S(h)=I+Ch⁴+…, el error de la aproximación fina puede estimarse mediante:

La extrapolación:

cancela el término dominante. Para aplicar la comparación, ambas particiones deben respetar la regla: en Simpson 1/3, n y 2n son pares.

function simpson13(f, a, b, n) {
  if (!Number.isInteger(n) || n < 2 || n % 2 !== 0) {
    throw new Error("n debe ser par");
  }
  const h = (b - a) / n;
  let suma = f(a) + f(b);
  for (let i = 1; i < n; i++) suma += (i % 2 ? 4 : 2) * f(a + i * h);
  return h * suma / 3;
}

function simpsonConError(f, a, b, n) {
  const gruesa = simpson13(f, a, b, n);
  const fina = simpson13(f, a, b, 2 * n);
  return {
    valor: fina,
    errorEstimado: Math.abs(fina - gruesa) / 15,
    extrapolada: (16 * fina - gruesa) / 15
  };
}

console.log(simpsonConError(Math.exp, 0, 1, 4));

14 · Exploración interactiva

Laboratorio: integrar parábolas por paneles

La línea dorada muestra los interpolantes cuadráticos de Simpson 1/3 y la línea clara discontinua representa la función original. Compará su error con el trapecio usando los mismos nodos.

Preguntas para explorar

1. En x⁴, duplicá n y observá si el error disminuye cerca de dieciséis veces.
2. Compará Simpson y trapecio con la misma cantidad de nodos.
3. En Runge, observá cómo los paneles cercanos al centro necesitan más resolución.
4. Probá sin(x): ¿la parábola queda siempre del mismo lado de la curva?

15 · Comprensión

Confusiones frecuentes

16 · Práctica guiada

Ejercicios

Ejercicio 1: Simpson simple

Usá los valores f(0)=1, f(1)=2 y f(2)=5 con h=1.

Ejercicio 2: patrón de pesos

Escribí los pesos de Simpson 1/3 para seis subintervalos.

Ejercicio 3: grado de exactitud

¿Por qué Simpson integra exactamente f(x)=3x³−2x+7?

Ejercicio 4: reducción del error

Si el error es 0.008 y duplicamos una partición en régimen asintótico, ¿qué error esperamos?

Ejercicio 5: elección de paneles

¿Cómo cubrirías nueve subintervalos uniformes con reglas de Simpson?

17 · Síntesis

Ideas para recordar

En el próximo tema convertiremos estas ideas en integración adaptativa, refinando solamente los subintervalos que necesitan mayor resolución.