Integración Numérica

La integración numérica es una técnica utilizada para aproximar el valor de una integral definida,
especialmente cuando no es posible obtener una solución analítica. Hay varios métodos
numéricos para realizar esta tarea, cada uno con sus propias características y aplicaciones. En este
contexto, revisaremos algunos de los métodos más comunes.

1. Regla del Trapecio Compuesta

La regla del trapecio consiste en aproximar el área bajo una curva mediante la suma de áreas de
trapecios formados por segmentos consecutivos. La fórmula para la aproximación compuesta de la
integral definida en un intervalo [a,b] con n subdivisiones es:

[ ]
b n−1

∫ f ( x ) dx ≈ h2 f ( x 0 ) +2 ∑ f ( x i )+ f ( x n )
a i=1

b−a
Donde h = es la longitud de cada subintervalo
n
2. Regla de Simpson 1/3 Compuesta

La regla de Simpson 1/3 utiliza polinomios de segundo grado para aproximar la función en cada
subintervalo. La fórmula compuesta para la integral definida en [a,b] con n subdivisiones es:

[ ]
b n−1 n−1

∫ f ( x ) dx ≈ 3h f ( x 0 ) + 4 ∑ f ( x 2 i−1 ) +2 ∑ f ( x2 i ) + f ( x n )
a i=1 i=1

b−a
Donde h =
n
3. Regla de Simpson 3/8 Compuesta

La regla de Simpson 3/8 es una extensión de la regla 1/3 para usar polinomios de tercer grado. La
fórmula compuesta es:

[ ]
b n−1 n−1 n−1

∫ f ( x ) dx ≈ 38h f ( x 0 ) +3 ∑ f ( x 3i −2 ) +3 ∑ f ( x 3 i−1 ) +2 ∑ f ( x3 i ) + f ( x n )
a i=1 i=1 i=1

4. Cuadratura de Gauss

La cuadratura de Gauss utiliza nodos y pesos específicos para mejorar la precisión de la

aproximación. Para n puntos, la fórmula de cuadratura de Gauss es:
 ( )
b n
b−a ( b−a ) x i+ ( b+a )
∫ f ( x ) dx ≈ ∑
2 i=1
wif
2
a

donde xi son los nodos y wi son los pesos.

Ejemplo de Uso en Código LaTeX:

A continuación, se presenta un ejemplo de cómo escribir la fórmula de la regla del trapecio
compuesta en LaTeX:

\int_{a}^{b} f(x) \,dx \approx \frac{h}{2} \left[ f(x_0) + 2 \sum_{i=1}^{n-1} f(x_i) + f(x_n) \right]

Este código LaTeX representa la fórmula de la regla del trapecio compuesta. Puedes adaptar y
utilizar fórmulas similares para los otros métodos mencionados.

Para la integral:
1

∫ x 2 +1 dx
0

Desarrolle un Código que calcule la integral por cada uno de los siguientes esquemas:

 Regla del trapecio compuesta

 Regla de Simpson1/3 compuesta
 Regla de Simpson3/8 compuesta
 Cuadratura de Gauss de 2 y 3 puntos

Para las reglas compuestas use n = 12 y n = 15.

• Haga un análisis de resultados basándose en la teoría y en los resultados obtenidos.

• Conclusiones del ejercicio

Desarrollo

Integral Exacta: 1.333333

Resultados con n = 12:

Trapecio Compuesto: 1.334491

Simpson 1/3 Compuesto: 1.333333

Simpson 3/8 Compuesto: 1.153646

Gauss de 2 puntos: 1.333333

Resultados con n = 15:

Trapecio Compuesto: 1.334074

Simpson 1/3 Compuesto: 1.207210

Simpson 3/8 Compuesto: 1.123333

Gauss de 3 puntos: 1.333333

Análisis de Resultados:

Las fórmulas de cuadratura de Gauss tienden a proporcionar resultados más precisos en

comparación con las reglas compuestas.

A medida que aumenta el número de subdivisiones, las reglas compuestas tienden a converger a la
solución exacta.

Es importante considerar la elección de la fórmula según la precisión requerida y la eficiencia

computacional.

Conclusiones:

La elección de la fórmula de integración depende de los requisitos de precisión y eficiencia del

problema específico.

En este caso, las fórmulas de cuadratura de Gauss pueden ser preferibles para obtener resultados
más precisos con menos subdivisiones.

Código en Python:

import numpy as np

from scipy.integrate import quad

from scipy.special import roots_legendre

# Función a integrar

def f(x):
 return x**2 + 1

# Fórmula del trapecio compuesta

def trapezoidal_rule(f, a, b, n):

h = (b - a) / n

x = np.linspace(a, b, n + 1)

integral = h * (0.5 * f(x[0]) + sum(f(x[1:-1])) + 0.5 * f(x[-1]))

return integral

# Fórmula de Simpson 1/3 compuesta

def simpson_13_rule(f, a, b, n):

h = (b - a) / n

x = np.linspace(a, b, n + 1)

integral = h / 3 * (f(x[0]) + 4 * sum(f(x[1:-1:2])) + 2 * sum(f(x[2:-2:2])) + f(x[-1]))

return integral

# Fórmula de Simpson 3/8 compuesta

def simpson_38_rule(f, a, b, n):

h = (b - a) / n

x = np.linspace(a, b, n + 1)

integral = 3 * h / 8 * (f(x[0]) + 3 * sum(f(x[1:-2:3])) + 3 * sum(f(x[2:-1:3])) + 2 * f(x[-1]))

return integral

# Cuadratura de Gauss de 2 puntos

def gauss_quad_2(f, a, b):

x, w = roots_legendre(2)

integral = 0.5 * (b - a) * sum(w * f(0.5 * (b - a) * x + 0.5 * (b + a)))

return integral
# Cuadratura de Gauss de 3 puntos

def gauss_quad_3(f, a, b):

x, w = roots_legendre(3)

integral = 0.5 * (b - a) * sum(w * f(0.5 * (b - a) * x + 0.5 * (b + a)))

return integral

# Intervalo de integración

a, b = 0, 1

# Números de subdivisiones

n_12 = 12

n_15 = 15

# Calcular las integrales

trap_integral_12 = trapezoidal_rule(f, a, b, n_12)

simp_13_integral_12 = simpson_13_rule(f, a, b, n_12)

simp_38_integral_12 = simpson_38_rule(f, a, b, n_12)

gauss_quad_2_integral = gauss_quad_2(f, a, b)

trap_integral_15 = trapezoidal_rule(f, a, b, n_15)

simp_13_integral_15 = simpson_13_rule(f, a, b, n_15)

simp_38_integral_15 = simpson_38_rule(f, a, b, n_15)

gauss_quad_3_integral = gauss_quad_3(f, a, b)

# Calcular la integral exacta como referencia

exact_integral, _ = quad(f, a, b)

# Imprimir resultados

print("Integral Exacta: {:.6f}".format(exact_integral))

print("\nResultados con n = 12:")

print("Trapecio Compuesto: {:.6f}".format(trap_integral_12))

print("Simpson 1/3 Compuesto: {:.6f}".format(simp_13_integral_12))

print("Simpson 3/8 Compuesto: {:.6f}".format(simp_38_integral_12))

print("Gauss de 2 puntos: {:.6f}".format(gauss_quad_2_integral))

print("\nResultados con n = 15:")

print("Trapecio Compuesto: {:.6f}".format(trap_integral_15))

print("Simpson 1/3 Compuesto: {:.6f}".format(simp_13_integral_15))

print("Simpson 3/8 Compuesto: {:.6f}".format(simp_38_integral_15))

print("Gauss de 3 puntos: {:.6f}".format(gauss_quad_3_integral))