🧪 Ejercicio: aproximar con Simpson y comparar

Vamos a aplicar el método de Simpson compuesto para aproximar el valor de la siguiente integral:

Esta integral tiene un valor exacto conocido:

¿Qué se va a hacer?

1. Calcular el valor exacto simbólicamente con sympy.
2. Aproximar la integral usando simpson(f, 0, 2, n) con varios valores de $n$ (por ejemplo: 2, 4, 8, 16, 32).
3. Comparar con el valor entregado por scipy.integrate.quad.
4. Graficar cómo evoluciona el error porcentual al aumentar $n$.

✅ Solución

import numpy as np
import matplotlib.pyplot as plt
from sympy import symbols, integrate, atan
from scipy.integrate import quad
 
# Función a integrar
def f(x):
    return 1 / (1 + x**2)
 
# Implementación del método de Simpson
def simpson(f, a, b, n):
    if n % 2 != 0:
        raise ValueError("n debe ser par.")
    h = (b - a) / n
    suma = f(a) + f(b)
    for i in range(1, n):
        x_i = a + i * h
        if i % 2 == 0:
            suma += 2 * f(x_i)
        else:
            suma += 4 * f(x_i)
    return (h / 3) * suma

🧠 1. Valor exacto con SymPy

x = symbols('x')
I_exact = integrate(1 / (1 + x**2), (x, 0, 2))
print("Valor exacto con SymPy:", I_exact.evalf())  # Esto imprime arctan(2)

Esto imprime:
Valor exacto con SymPy: 1.107148717794090

🧠 2. Comparar con Scipy (quad)

quad_result, quad_error = quad(f, 0, 2)
print(f"Valor con quad: {quad_result:.10f} (error estimado: {quad_error:.1e})")

Esto imprime algo como:
Valor con quad: 1.1071487178 (error estimado: 1.23e-14)

📊 3. Comparar resultados con Simpson para varios valores de n

n_values = [2, 4, 8, 16, 32, 64]
simpson_vals = []
errors = []
exact_val = float(I_exact.evalf())
 
for n in n_values:
    approx = simpson(f, 0, 2, n)
    simpson_vals.append(approx)
    error_pct = abs((exact_val - approx) / exact_val) * 100
    errors.append(error_pct)
    print(f"n = {n:<3} → Aproximación = {approx:.10f} → Error = {error_pct:.6f}%")

Salida esperada:

n = 2 → Aproximación = 1.1072796930 → Error = 0.011834%
n = 4 → Aproximación = 1.1071509875 → Error = 0.000205%
n = 8 → Aproximación = 1.1071487412 → Error = 0.000002%

📈 4. Graficar el error

plt.figure(figsize=(8, 5))
plt.plot(n_values, errors, marker='o')
plt.title("Error porcentual vs número de subintervalos (Simpson)")
plt.xlabel("n (número de subintervalos)")
plt.ylabel("Error porcentual")
plt.grid(True)
plt.show()

🧪 Ejercicio: cuando la función “parece fácil”… pero no lo es

En este ejercicio se pondrá a prueba el método de Simpson compuesto con una función que visualmente parece inofensiva, pero que esconde un comportamiento que desafía nuestra intuición.

Considerar la función:

en el intervalo $[0, 1]$.

¿Qué se debe hacer?

1. Graficar la función $f(x)$ en el intervalo $[0, 1]$.

2. Aplicar el método de Simpson compuesto para aproximar la integral definida:

   $$\int_0^1 \sin(10x^2)\,dx$$
   • Utilizar varios valores de $n$: por ejemplo $n = 2,\ 4,\ 8,\ 16,\ 32,\ 64,\ 128$.
   • Registrar el valor aproximado para cada $n$.

3. Comparar los resultados con la solución obtenida usando quad de scipy.integrate.

   • Calcular el error absoluto o porcentual para cada caso.
   • Representar gráficamente el error en función de $n$.

Este ejercicio busca mostrar que no todas las funciones suaves son “fáciles” de integrar numéricamente, y que la curvatura o la oscilación pueden jugar un papel muy importante.

🧠 Preguntas

Responder con una o dos frases. Justificar las respuestas observando las gráficas y los resultados obtenidos.

1. ¿Qué observaste al graficar la función $f(x) = \sin(10x^2)$ en el intervalo $[0, 1]$? ¿Es lo que esperabas?

2. ¿Cómo se comporta el error absoluto al aumentar el número de subintervalos $n$?

3. ¿El error disminuye de forma regular como en ejercicios anteriores? ¿O presenta saltos, zonas planas o comportamientos inesperados?