Tarea: Realizar en Python con diferentes métodos de integrales bajo la curva, Simpson 3/8, 1/8,

Riemnan, ABC import numpy as np

import [Link] as plt
2
1. ∫ 7 𝑑𝑥 #Definimos la función
0 def f(x):
𝑎 = 0, 𝑏 = 2, 𝑓(𝑥) = 7 return 7 * np.ones_like(x) # f(x) = 7 (constante)

2−0 2 #Definimos los puntos x

ℎ= = a, b = 0, 2 # límites de integración
3 3 x = [Link](a, b, 4) # 4 puntos (para Simpson
Puntos: 3/8)
y = f(x)
2 4
𝑥0 = 0, 𝑥1 = , 𝑥2 = , 𝑥3 = 2
3 3 #Calculamos el área bajo la curva método de Simpson
2
3ℎ 3/8
∫ 7 𝑑𝑥 = [𝑓(𝑥0 ) + 3𝑓(𝑥1 ) + 3𝑓 (𝑥2 ) + 𝑓(𝑥3 )] h = (b - a) / 3
0 8 area = (3 * h / 8) * (y[0] + 3*y[1] + 3*y[2] + y[3])
3(2/3)
= [7 + 3(7) + 3(7) + 7] print("Puntos x:", x)
8 print("Valores f(x):", y)
2 print(f"Área bajo la curva (Simpson 3/8): {area:.4f}")
= [7 + 21 + 21 + 7]
8
1 #Graficamos
= (56) [Link](x, y, 'ro-', label='f(x) = 7')
4 plt.fill_between(x, y, color='skyblue', alpha=0.4)
= 14 [Link]('Método de Simpson 3/8')
[Link]('x')
[Link]('f(x)')
[Link]()
[Link](True)
[Link]()
 import numpy as np
2 import [Link] as plt
3. ∫ 5𝑥 𝑑𝑥 𝑎 = 1, 𝑏 = 2, 𝑓(𝑥) = 5𝑥,
#Definimos la función
1 def f(x):
return 5 * x
2−1 1
ℎ= = #Definimos los puntos del intervalo
3 3
a, b = 1, 2 # límites de integración
Puntos: n = 3 #Simpson 3/8 requiere que el número de subintervalos sea múltiplo de 3
h = (b - a) / n # ancho de cada subintervalo
1 4 2 5
𝑥0 = 1, 𝑥1 = 1 + 3 = 3, 𝑥2 = 1 + 3 = 3, 𝑥3 = 2 # Puntos x
x = [Link](a, b, n + 1)
Evaluamos la función 𝑓(𝑥) = 5𝑥 en cada uno de estos puntos: y = f(x)

4 4 20 #Aplicamos la fórmula de Simpson 3/8

𝑓 (𝑥0 ) = 𝑓 (1) = 5(1) = 5 𝑓 (𝑥1 ) = 𝑓 (3) = 5 (3) = # Integral ≈ (3h/8)[f(x0) + 3f(x1) + 3f(x2) + f(x3)]
3
5 5 25 I = (3 * h / 8) * (y[0] + 3*y[1] + 3*y[2] + y[3])
𝑓 (𝑥2 ) = 𝑓 (3) = 5 (3) = 𝑓(𝑥3 ) = 𝑓(2) = 5(2)
3
print(f"Resultado aproximado con Simpson 3/8: {I:.4f}")
2
3ℎ #Graficamos la función y las áreas
∫ 5𝑥 𝑑𝑥 = [𝑓(𝑥0 ) + 3𝑓(𝑥1 ) + 3𝑓(𝑥2 ) + 𝑓 (𝑥3 )]
1 8 x_plot = [Link](a, b, 100)
y_plot = f(x_plot)
3(1/3) 20 25
= [5 + 3 ( ) + 3 ( ) + 10] [Link](x_plot, y_plot, 'b', label='f(x) = 5x')
8 3 3 plt.fill_between(x_plot, y_plot, color='skyblue', alpha=0.3)
1 60 75 # Marcar los puntos usados por Simpson 3/8
= [5 + ( ) + ( ) + 10]
8 3 3 [Link](x, y, color='red', zorder=5)
for i in range(len(x)):
1 [Link](x[i], 0, y[i], colors='r', linestyles='dashed', alpha=0.7)
= [5 + 20 + 25 + 10]
8
[Link]("Método de Simpson 3/8 para ∫₁² 5x dx")
1 [Link]("x")
= [60] [Link]("f(x)")
8
[Link]()
60 15 [Link](True)
= = [Link]()
8 2
= 7.5
 75 𝑛(𝑛 + 1) 75 𝑛2 + 𝑛
5 𝑠𝑛 = − ∗ =− ∗( )
2 𝑛2 2 𝑛2
4. ∫ −3𝑥 𝑑𝑥
0 75 𝑛2 𝑛 75 1
𝑠𝑛 = − ∗ ( 2 + 2 ) = − ∗ (1 + )
𝑎 = 0, 𝑏 = 5, 𝑓(𝑥 ) = −3𝑥 2 𝑛 𝑛 2 𝑛
5
𝑏−𝑎 5−0 5 75 1
△𝑥 = = = ∫ −3𝑥 𝑑𝑥 = lim 𝑠𝑛 = lim [− ∗ (1 + )]
𝑛 𝑛 𝑛 0 𝑛→∞ 𝑛→∞ 2 𝑛

5 5𝑖 75 75
𝑥𝑖∗ = 𝑎 + 𝑖 △𝑥 = 0 + 𝑖 ( ) = =− ∗ (1 + 0) = −
𝑛 𝑛 2 2
= −37.5
5𝑖 5𝑖 15𝑖
𝑓(𝑥𝑖∗ ) = 𝑓 ( ) = −3 ( ) = − import numpy as np
𝑛 𝑛 𝑛 import [Link] as plt
𝑛 𝑛
15𝑖 5 #Definimos la función ---
𝑠𝑛 = ∑ 𝑓(𝑥𝑖∗ ) △𝑥 = ∑ (− )( ) def f(x):
"""Función a integrar: f(x) = -3x"""
𝑛 𝑛 return -3 * x
𝑖=1 𝑖=1
𝑛 #Definimos los puntos y parámetros ---
15 5 a, b = 0, 5 # Límites de integración
𝑠𝑛 = (− ∗ ) ∑ 𝑖 n = 50 # Número de subintervalos (¡Aumenta este número para mejor
𝑛 𝑛 precisión!)
𝑖=1 dx = (b - a) / n # Ancho de cada subintervalo
𝑛
75 # Usamos el extremo derecho (tipo = 'derecha')
# Puntos de división: x0, x1, ..., xn
𝑠𝑛 = − 2 ∑ 𝑖 x_division = [Link](a, b, n + 1)
𝑛
𝑖=1
# Puntos de muestreo (excluye x0, incluye xn)
𝑛 x_riemann = x_division[1:]
𝑛(𝑛 + 1)
∑𝑖 = # --- 3. Calculamos el área bajo la curva (Suma de Riemann) ---
2 # f(x_riemann) son las alturas de los rectángulos
𝑖=1 # dx es la base de los rectángulos
area_riemann = [Link](f(x_riemann) * dx)
75 𝑛(𝑛 + 1)
𝑠𝑛 = − 2 [ ] # Cálculo del resultado exacto para comparación: Integral de -3x de 0 a 5
𝑛 2 # Exacto: [-3x²/2] de 0 a 5 = -3/2 * (5² - 0²) = -3/2 * 25 = -37.5
resultado_exacto = -37.5
print(f"Número de rectángulos (n) = {n}")
print(f"Área aproximada (Suma de Riemann) = {area_riemann:.6f}")
print(f"Resultado Exacto (Analítico) = {resultado_exacto:.6f}")
print(f"Error absoluto = {abs(area_riemann - resultado_exacto):.6f}")

#Graficamos la función y los rectángulos ---

x_plot = [Link](a - 0.5, b + 0.5, 100) # Rango extendido para la gráfica
y_plot = f(x_plot)

[Link](figsize=(10, 6))

# Gráfico de la función
[Link](x_plot, y_plot, 'b', linewidth=2, label='f(x) = -3x')
[Link](0, color='gray', linewidth=0.8) # Eje x
[Link](a, color='green', linestyle='--', label=f'a={a}')
[Link](b, color='red', linestyle='--', label=f'b={b}')

# Dibujar los rectángulos (extremo derecho)

# La base de la barra se sitúa en el centro (align='center') de x_riemann,
# lo que ajusta las barras para que terminen en los puntos x_division[1:]
[Link](x_riemann - dx/2, f(x_riemann), width=dx, align='center',
alpha=0.5, edgecolor='k', color='orange', label=f'Rectángulos (n={n})')

# Configuración del Gráfico

[Link](f'Aproximación por Suma de Riemann (Extremo Derecho) para $\int_0^5 -3x \,dx$')
[Link]('x')
[Link]('f(x)')
[Link]()
[Link](True, linestyle='--')
[Link](a - 0.5, b + 0.5)
[Link]()
 1 import numpy as np
5. ∫ (2𝑥 − 3)𝑑𝑥 import [Link] as plt
−3
# 1. Definimos la función
𝑎 = 𝑥0 = −3, 𝑏 = 𝑥3 = 1, 𝑓(𝑥) = 2𝑥 − 3 def f(x):
return 2*x - 3
1 − (−3) 4
ℎ= =
3 3 # 2. Definimos los puntos x
a, b = -3, 1
Puntos: x = [Link](a, b, 4) # 4 puntos → 3 subintervalos
y = f(x)
4 5 5 4 1 1 4 3
𝑥0 = −3, 𝑥1 = −3 + 3 = − 3, 𝑥2 = − 3 + 3 = − 3, 𝑥3 = − 3 + 3 = 3 = 1
# 3. Aplicamos el método de Simpson 3/8
Evaluamos la función 𝑓 (𝑥 ) = 2𝑥 − 3 en cada uno de estos puntos: h = (b - a) / 3
area = (3*h/8) * (y[0] + 3*y[1] + 3*y[2] + y[3])
5 5 19
𝑓 (𝑥0 ) = 𝑓 (−3) = 2(−3) − 3 = −9 𝑓 (𝑥1 ) = 𝑓 (− 3) = 2 (− 3) − 3 = − 3
1 1 11
print("Puntos x:", x)
𝑓 (𝑥2 ) = 𝑓 (− 3) = 2 (− 3) − 3 = − 𝑓 (𝑥3 ) = 𝑓 (1) = 2(1) − 3 = −1 print("Valores f(x):", y)
3
print(f"Área bajo la curva (Simpson 3/8): {area:.4f}")
1
3ℎ
∫ (2𝑥 − 3) 𝑑𝑥 = [𝑓(𝑥0 ) + 3𝑓(𝑥1 ) + 3𝑓(𝑥2 ) + 𝑓(𝑥3 )] # 4. Graficamos
−3 8 [Link](x, y, 'ro-', label='f(x) = 2x - 3')
3(4/3) 19 11 plt.fill_between(x, y, color='lightblue', alpha=0.5)
= [−9 + 3 (− ) + 3 (− ) + (−1)] [Link]('Método de Simpson 3/8')
8 3 3 [Link]('x')
[Link]('f(x)')
1
= [−9 + (−19) + (−11) − 1] [Link]()
2 [Link](True)
[Link]()
1
= [−9 − 19 − 11 − 1]
2
1
= [−40]
2
= −20
 1
import numpy as np
6. ∫ (4 − 9𝑦) 𝑑𝑦 import [Link] as plt
−1
𝑎 = −1, 𝑏 = 1, 𝑓(𝑥) = 4 − 9𝑦 # 1. Definimos la función
def f(y):
1 − (−1) 2
ℎ= = =1 return 4 - 9*y
2 2
Puntos: # 2. Definimos los puntos y
a, b = -1, 1
𝑦0 = −1, 𝑦1 = −1 + 1 = 0, 𝑦2 = 1 y_points = [Link](a, b, 3) # 3 puntos → 2
subintervalos
Evaluamos la función 𝑓 (𝑥 ) = 2𝑥 − 3 en cada uno de estos puntos:
f_values = f(y_points)
𝑓 (𝑦0 ) = 𝑓(−1) = 4 − 9(−1) = 13 𝑓 (𝑦1) = 𝑓 (0) = 4 − 9(0) = 4
𝑓 (𝑦2 ) = 𝑓(1) = 4 − 9(1) = −5 # 3. Aplicamos el método de Simpson 1/3
1 h = (b - a) / 2
ℎ area = (h / 3) * (f_values[0] + 4*f_values[1] +
∫ (4 − 9𝑦) 𝑑𝑦 = [𝑓(𝑦0 ) + 3𝑓(𝑦1 ) + 3𝑓(𝑦2 )]
−1 3 f_values[2])
1
= [13 + 4(4) + (−5)] print("Puntos y:", y_points)
3 print("Valores f(y):", f_values)
1 print(f"Área bajo la curva (Simpson 1/3): {area:.4f}")
= [13 + 13 − 5]
3
# 4. Graficamos
1
= [24] [Link](y_points, f_values, 'ro-', label='f(y)= 4 - 9y')
2 plt.fill_between(y_points, f_values, color='lightblue',
=8 alpha=0.5)
[Link]('Método de Simpson 1/3')
[Link]('y')
[Link]('f(y)')
[Link]()
[Link](True)
[Link]()
 import numpy as np
import [Link] as plt

3 # función
2 def f(y):
7. ∫ (𝑦 − 2𝑦 + 1)𝑑𝑦 return y**2 - 2*y + 1 # = (y-1)**2
2
a, b = 2.0, 3.0
𝑎 = 2, 𝑏 = 3 def riemann(n, kind='right'):
dy = (b - a) / n
𝑏−𝑎 3−1 1 x = [Link](a, b, n+1)
if kind == 'left':
△𝑦 = = = , sample = x[:-1]
𝑛 𝑛 𝑛 elif kind == 'right':
sample = x[1:]
𝑖 elif kind == 'mid':
𝑦𝑖 = 2 + 𝑖 △𝑦 = 2 + , 𝑖 = 0, … , 𝑛. sample = (x[:-1] + x[1:]) / 2
𝑛 else:
raise ValueError("kind debe ser 'left','right' o 'mid'")
𝑛 𝑛 2 return [Link](f(sample) * dy)
𝑖 1
𝑠𝑛 = ∑ 𝑓 (𝑦𝑖 ) △𝑦 = ∑ ((2 + − 1) ) for n in [4, 10, 100, 1000]:
𝑛 𝑛 print(f"n={n}: left={riemann(n,'left'):.6f}, mid={riemann(n,'mid'):.6f},
𝑖=1 𝑖=1
right={riemann(n,'right'):.6f}")
𝑛 𝑛 𝑛
1 2 1 # grafica
𝑠𝑛 = ∑ 1 + 2 ∑ 𝑖 + 3 ∑ 𝑖 2 n=50
x_plot = [Link](a,b,500)
𝑛 𝑛 𝑛 [Link](x_plot, f(x_plot), label='f(y)=(y-1)^2')
𝑖=1 𝑖=1 𝑖=1 x = [Link](a,b,n+1)
𝑛 𝑛 𝑛 mid = (x[:-1]+x[1:])/2
𝑛(𝑛 + 1) 𝑛(𝑛 + 1)(2𝑛 + 1) [Link](mid, f(mid), width=(b-a)/n, alpha=0.4, edgecolor='k', label='Rectángulos (punto medio)')
∑ 1 = 𝑛, ∑ 𝑖 = , ∑ 𝑖2 = [Link](); [Link]('y'); [Link]('f(y)'); [Link](True);
2 6
𝑖=1 𝑖=1 𝑖=1 [Link]()

𝑛 + 1 (𝑛 + 1)(2𝑛 + 1)
𝑠𝑛 = 1 + +
𝑛 6𝑛2
7 3 1
𝑠𝑛 = + + 2
3 2𝑛 6𝑛
7
lim 𝑠𝑛 =
𝑛→∞ 3
= 2.33
 2
8. ∫ (2𝑡 − 𝑡 2 )𝑑𝑡 import numpy as np
import [Link] as plt
3
#Definimos la función f(t) ---
def f(t):
"""
𝑎 = 3, 𝑏 = 2, 𝑓 (𝑡 ) = 2𝑡 − 𝑡 2 Función a integrar: f(t) = 2t - t^2
"""
2−3 1 return 2*t - t**2
ℎ= =− #Definimos los puntos (límites y subintervalos) ---
3 3 a = 3 # Límite inferior
b = 2 # Límite superior
Puntos: n = 3 # Número de subintervalos (debe ser múltiplo de 3 para Simpson 3/8)
# Calculamos el ancho de cada subintervalo (h o delta_t)
1 8 1 7 delta_t = (b - a) / n
𝑡0 = 3, 𝑡1 = 3 + (− 3) = 3, 𝑡2 = 3 + 2 (− 3) = 3, # Generamos los puntos de t
t_points = [Link](a, b, n + 1)
# Calculamos los valores de la función en esos puntos
𝑡3 = 2 f_points = f(t_points)
#Calculamos el área bajo la curva (Integral) usando Simpson 3/8 ---
Evaluamos la función 𝑓 (𝑥 ) = 2𝑥 − 3 en cada uno de estos puntos: # Regla de Simpson 3/8 (simple):
# I ≈ (3*h / 8) * [f(t_0) + 3*f(t_1) + 3*f(t_2) + f(t_3)]
𝑓 (𝑡0 ) = 𝑓(3) = 2(3) − 32 = 6 − 9 = −3
# Sumamos los términos internos: 3*f(t_1) + 3*f(t_2)
8 8 8 2 16 64 49 64 16 suma_interna = 3 * f_points[1] + 3 * f_points[2]
( )
𝑓 𝑡1 = 𝑓 ( ) = 2 ( ) − ( ) = − = − =− = −1.777
3 3 3 3 9 9 9 9 # Calculamos la aproximación final de la integral
2 integral_simpson_3_8 = (3 * delta_t / 8)*(f_points[0] + suma_interna +
7 7 7 14 49 42 49 7
𝑓 (𝑡2 ) = 𝑓 ( ) = 2 ( ) − ( ) = − = − = − = −0.777 f_points[3])
3 3 3 3 9 9 9 9
# Imprimimos el resultado
𝑓 (𝑡3 ) = 𝑓(2) = 2(2) − 22 = 4 + 4 = 0 print(f"--- Cálculo con el Método de Simpson 3/8 ---")
print(f"Límite inferior (a): {a}")
2
3ℎ print(f"Límite superior (b): {b}")
∫ (2𝑡 − 𝑡 2 ) 𝑑𝑡 = [𝑓(𝑡0 ) + 3𝑓(𝑡1 ) + 3𝑓(𝑡2 ) + 𝑓(𝑡3 )] print(f"Número de subintervalos (n): {n} (múltiplo de 3)")
3 8 print(f"Ancho del subintervalo (delta_t): {delta_t}")
print(f"\nValor de la Integral (Método de Simpson 3/8):
3(−1 /3) 16 7 {integral_simpson_3_8}")
= [−3 + 3 (− ) + 3 (− ) + 0] print(f"Valor Exacto (4/3): {4/3}")
8 9 9
1 16 7
= − [−3 − − ]
8 3 3
 #Graficamos la función y el área bajo la curva ---
# Rango de t para la gráfica (usamos más puntos para una curva suave)
1 23 t_range = [Link](min(a, b), max(a, b), 100)
= − [−3 − ] f_range = f(t_range)
8 3
1 9 23 [Link](figsize=(10, 6))
= − [− − ]
8 3 3 #Graficar la función
[Link](t_range, f_range, label='$f(t) = 2t - t^2$', color='green')
1 32
= − [− ] #Rellenar el área de la integral
8 3 # El área es negativa ya que integramos de 3 a 2.
t_fill = [Link](min(a, b), max(a, b), 100)
32 4 plt.fill_between(t_fill, f(t_fill), where=(t_fill >= min(a, b)) & (t_fill <= max(a, b)),
= = color='lightgreen', alpha=0.5, label='Región de la Integral')
24 3
= 1.3333 #Marcar los puntos usados para Simpson
[Link](t_points, f_points, color='red', zorder=5, label=f'Puntos de Simpson 3/8 (n={n})')

#Configuración de la gráfica
[Link](0, color='black', linewidth=0.8) # Eje t
[Link](0, color='black', linewidth=0.8) # Eje f(t)
[Link](f'Método de Simpson 3/8 para $\int_{{{a}}}^{{{b}}} (2t - t^2) dt$')
[Link]('t')
[Link]('f(t)')
[Link]()
[Link](True, linestyle='--', alpha=0.7)
[Link]()
 import numpy as np
import [Link] as plt
−1
9. ∫ (3𝑤 2 − 𝑤 − 1) 𝑑𝑤 #Definimos la función
def f(w):
−2
return 3*w**2 - w - 1
−1 − (−2) 1 #Definimos los puntos
ℎ= = = 0.5 a, b = -2, -1 # límites de integración
2 2 n = 2 # número de subintervalos (debe ser par)
h = (b - a) / n # ancho de cada subintervalo
𝑤0 = −2, 𝑤1 = −1.5, 𝑤2 = −1
w = [Link](a, b, n + 1) # nodos: w0, w1, w2
𝑤0 = −2: 𝑓 (−2) = 3(−2)2 − (−2) − 1 = 3 ∗ 4 + 2 − 1 = 12 + 2 − 1 = 13 y = f(w) # valores de la función

𝑤1 = −1.5: 𝑤12 = 2.25, 3𝑤 2 = 6.75, −𝑤1 = 1.5 #Calculamos el área con la regla de Simpson 1/3
area = (h / 3) * (y[0] + 4*y[1] + y[2])

𝑓(−1.5) = 6.75 + 1.5 − 1 = 7.25 print("Puntos w:", w)

print("Valores f(w):", y)
𝑤2 = −1: 𝑓(−1) = 3(1) − (−1) − 1 = 3 + 1 − 1 = 3 print("Área aproximada (Simpson 1/3):", area)

−1 #Graficamos
ℎ w_plot = [Link](a, b, 100)
∫ (3𝑤 2 − 𝑤 − 1) 𝑑𝑤 = (𝑤0 + 4𝑤1 + 𝑤2 ) [Link](w_plot, f(w_plot), label='f(w) = 3w² - w - 1', color='blue')
−2 3 plt.fill_between(w_plot, f(w_plot), alpha=0.2, color='skyblue')
[Link](w, y, color='red', label='Puntos de Simpson')
0.5 [Link]('Método de Simpson 1/3')
= (13 + 4 ∗ 7.25 + 3) [Link]('w')
3 [Link]('f(w)')
[Link]()
[Link](True)
4 ∗ 7.25 = 29, 13 + 29 + 3 = 45 [Link]()

0.5 0.5 ∗ 45 22.5

∗ 45 = =
3 3 3
= 7.5
 2 import numpy as np
−4 import [Link] as plt
11. ∫ −4𝑡 𝑑𝑡 #Definimos la función
1 def f(t):
return -4 * t**(-4)
𝑎 = 1, 𝑏 = 2 #Definimos los puntos
a, b = 1, 2
𝑏−𝑎 2−1 1 n = 100 # número de subdivisiones (entre más grande, más preciso)
△𝑡 = = = , t = [Link](a, b, n + 1)
𝑛 𝑛 𝑛 dt = (b - a) / n
# Usamos puntos derechos para la suma de Riemann
t_derecha = t[1:]
𝑡𝑖 = 1 + 𝑖 △𝑡 area = [Link](f(t_derecha) * dt)
𝑛 𝑛 print("Área aproximada (Suma de Riemann):", area)
𝑖 −4 1 #Valor exacto para comparar
𝑠𝑛 = ∑ 𝑓 (𝑡𝑖 ) △𝑦 = ∑ (−4 (1 + ) ) # ∫ -4t^-4 dt = (4/3)t^-3 + C
𝑛 𝑛 area_exacta = (4/3)*(2**-3 - 1**-3)
𝑖=1 𝑖=1 print("Área exacta:", area_exacta)
2 #Graficamos
𝑡 −3 4 −3 t_plot = [Link](a, b, 200)
∫ −4𝑡 −4 𝑑𝑡 = −4 ∗ = 𝑡 [Link](t_plot, f(t_plot), color='blue', label='f(t) = -4t⁻⁴')
1 −3 3 [Link](t_derecha, f(t_derecha), width=dt, alpha=0.3, align='edge', edgecolor='black')
plt.fill_between(t_plot, f(t_plot), alpha=0.1, color='skyblue')
4 −3 2 4 1 1 [Link]('Suma de Riemann (Puntos derechos)')
[ 𝑡 ] = ( 3 − 3) [Link]('t')
3 1 3 2 1 [Link]('f(t)')
[Link]()
4 1 4 7 7 [Link](True)
= ( − 1) = (− ) = − [Link]()
3 8 3 8 6
= −1.166
 import numpy as np
import [Link] as plt
2
𝑥 −2 𝑏−𝑎 2−1 1 # Definimos la función
12. ∫ 𝑑𝑥 𝑎 = 1, 𝑏 = 2, ℎ = = =
1 2 𝑛 3 3 def f(x):
return 1 / (2 * x**2)
1 4 2 5
𝑥0 = 1, 𝑥1 = 1 + = , 𝑥2 = 1 + = , 𝑥3 = 2 # Definimos los puntos
3 3 3 3
a = 1 # límite inferior
1 b = 2 # límite superior
Evaluamos la función 𝑓(𝑥) = en cada uno de estos puntos: n = 3 # número de subintervalos (múltiplo de 3 para Simpson 3/8)
2𝑥 2
h = (b - a) / n
1 1 1 1 9
𝑓 (𝑥0 ) = 2(1)2 = 2 = 0.5 𝑓 (𝑥1 ) = 3 2
= 16 = 32 = 0.28125
2( ) 2( ) x = [Link](a, b, n + 1)
4 9
y = f(x)
1 1 9 1 1
𝑓 (𝑥2 ) = 5 2
= 25 = 50 = 0.18 𝑓 (𝑥3 ) = 2(2)2 = 8 = 0.125
2( ) 2( ) # Calculamos el área bajo la curva (Simpson 3/8)
3 9
area = (3 * h / 8) * (y[0] + 3*y[1] + 3*y[2] + y[3])
2
𝑥 −2 3ℎ
∫ 𝑑𝑥 = [𝑓(𝑥0 ) + 3𝑓(𝑥1 ) + 3𝑓(𝑥2 ) + 𝑓(𝑥3 )] print(f"Área aproximada con Simpson 3/8: {area:.6f}")
1 2 8
# Graficamos
3(1/3) x_plot = [Link](a, b, 100)
= [0.5 + 3(0.28125) + 3(0.18) + 0.125] y_plot = f(x_plot)
8
1 [Link](figsize=(8,5))
= [0.5 + 0.84375 + 0.54 − 0.125] [Link](x_plot, y_plot, 'b', label='f(x) = 1/(2x²)')
8 plt.fill_between(x, y, color='lightgreen', alpha=0.5, label='Área aproximada')
[Link](x, y, color='red', zorder=5)
1
= [2.00875] # Líneas verticales para los subintervalos
8 for xi in x:
[Link](x=xi, color='gray', linestyle='--', alpha=0.6)
= 0.2511
[Link]('Método de Simpson 3/8')
[Link]('x')
[Link]('f(x)')
[Link]()
[Link](True)
[Link]()
 import numpy as np
import [Link] as plt
1
3
13. ∫ √𝑥 5 𝑑𝑥 # 1. Definimos la función
−1 def f(x):
return [Link](x**5) # raíz cúbica de x^5
𝑏 − 𝑎 1 − (−1)
𝑎 = −1, 𝑏 = 1, ℎ = = =1 # 2. Definimos los puntos
𝑛 2 a = -1
b = 1
𝑥0 = −1, 𝑥1 = 0, 𝑥2 = 1 n = 2 # número de subintervalos (par)
h = (b - a) / n
5
𝑓(𝑥0 ) = (−1)3 = −1, 𝑓(𝑥1 ) = 0, 𝑓 (𝑥2 ) = 1 x = [Link](a, b, n + 1)
1 y = f(x)
3 ℎ
∫ √𝑥 5 𝑑𝑥 = [𝑓(𝑥0 ) + 4𝑓(𝑥1 ) + 𝑓(𝑥2 )] # 3. Calculamos el área bajo la curva (Simpson 1/3)
−1 8 area = (h / 3) * (y[0] + 4*y[1] + y[2])

1 print(f"Área aproximada con Simpson 1/3: {area:.6f}")

= [−1 + 4(0) + 1]
3 # 4. Graficamos
x_plot = [Link](a, b, 200)
1 y_plot = f(x_plot)
= (0) = 0
3 [Link](figsize=(8,5))
[Link](x_plot, y_plot, 'b', label='f(x) = ∛(x⁵)')
plt.fill_between(x_plot, y_plot, color='lightblue',
alpha=0.5)
[Link](x, y, color='red', zorder=5)

for xi in x:
[Link](x=xi, color='gray', linestyle='--',
alpha=0.6)

[Link]('Método de Simpson 1/3')

[Link]('x')
[Link]('f(x)')
[Link]()
[Link](True)
[Link]()
 𝑛 𝑛
3/2 1 7 1 1
14. ∫ (𝑥 2 + 𝑥 + 1)𝑑𝑥 = (𝑛 ∗ + 2 ∑ 𝑖 + 2 ∑ 𝑖 2
𝑛 4 𝑛 𝑛
1/2 𝑖=1 𝑖=1

1 3 7 2 𝑛(𝑛 + 1) 1 𝑛(𝑛 + 1)(2𝑛 + 1)

𝑓(𝑥 ) = 𝑥 2 + 𝑥 + 1, [𝑎, 𝑏] = [ , ] 𝑠𝑛 = + ∗ + 3∗
2 2 4 𝑛2 2 𝑛 6
7 𝑛 + 1 𝑛 𝑛 + 1 2𝑛 + 1)
( )(
3 1 = + +
𝑏−𝑎 2−2 1 4 𝑛 6𝑛2
△𝑥 = = =
𝑛 𝑛 𝑛 7 1 7 4 1 21 12 4 37
lim 𝑠𝑛 = + 1 + = + + = + + =
1 𝑖 𝑛→∞ 4 3 4 4 3 12 12 12 12
𝑥𝑖 = 𝑎 + 𝑖 △𝑥 = + (𝑖 = 1, … , 𝑛)
2 𝑛 = 3.0833
𝑛 𝑛
1 1 𝑖
𝑠𝑛 = ∑ 𝑓(𝑥𝑖 ) △𝑥 = ∑ [( + ) + 1]
𝑛 2 𝑛
𝑖=1 𝑖=1

1 𝑖 2 1 𝑖
( + ) +( + )+1
2 𝑛 2 𝑛
1 𝑖 𝑖2 1 𝑖
= + + 2+ + +1
4 𝑛 𝑛 2 𝑛
7 𝑖 𝑖2
= +2 + 2
4 𝑛 𝑖
𝑛
1 7 𝑖 𝑖2
𝑠𝑛 = ∑ ( + 2 + 2 )
𝑛 4 𝑛 𝑖
𝑖=1
import numpy as np
import [Link] as plt

# 1. Definimos la función
def f(x):
return x**2 + x + 1

# 2. Definimos el intervalo y número de subdivisiones

a = 0.5
b = 1.5
n = 1000 # número de subintervalos
h = (b - a) / n

# 3. Puntos medios
x_mid = a + ([Link](1, n + 1) - 0.5) * h
y_mid = f(x_mid)

# 4. Suma de Riemann (punto medio)

area = h * [Link](y_mid)

print(f"Área aproximada (Suma de Riemann por punto medio): {area:.6f}")

# 5. Gráfica
x_plot = [Link](a, b, 400)
y_plot = f(x_plot)

[Link](figsize=(8,5))
[Link](x_plot, y_plot, 'b', label='f(x) = x² + x + 1')
[Link](x_mid, y_mid, width=h, alpha=0.4, color='orange', edgecolor='black', label='Rectángulos
Riemann (punto medio)')
[Link]('x')
[Link]('f(x)')
[Link]('Suma de Riemann - Método del punto medio')
[Link]()
[Link](True)
[Link]()
 import numpy as np
import [Link] as plt
3
1 # 1. Definimos la función
15. ∫ 2
𝑑𝑥 def f(x):
1/2 𝑥 return 1 / x**2

# 2. Definimos los puntos

a = 0.5
b = 3
n = 3 # múltiplo de 3
h = (b - a) / n

x = [Link](a, b, n + 1)
y = f(x)

# 3. Aplicamos Simpson 3/8

area = (3 * h / 8) * (y[0] + 3*y[1] + 3*y[2] + y[3])

print(f"Área aproximada con Simpson 3/8: {area:.6f}")

# 4. Graficamos
x_plot = [Link](a, b, 200)
y_plot = f(x_plot)

[Link](figsize=(8,5))
[Link](x_plot, y_plot, 'b', label='f(x) = 1/x²')
plt.fill_between(x, y, color='lightgreen', alpha=0.5, label='Área aproximada')
[Link](x, y, color='red', zorder=5)

# Líneas verticales
for xi in x:
[Link](x=xi, color='gray', linestyle='--', alpha=0.6)

[Link]('Método de Simpson 3/8')

[Link]('x')
[Link]('f(x)')
[Link]()
[Link](True)
[Link]()
 9
1
16. ∫ ( − 2) 𝑑𝑥
4 √𝑥

import numpy as np
import [Link] as plt

# 1. Definimos la función
def f(x):
return 1/[Link](x) - 2

# 2. Definimos los puntos

a = 4 # límite inferior
b = 9 # límite superior
n = 4 # número de subintervalos (debe ser par)
h = (b - a) / n

x = [Link](a, b, n + 1) # puntos
y = f(x) # valores de la función

# 3. Calculamos el área bajo la curva (Regla de Simpson 1/3)

S = y[0] + y[-1] + 4 * [Link](y[1:-1:2]) + 2 * [Link](y[2:-2:2])
I = (h / 3) * S

print(f"Integral aproximada (Simpson 1/3) = {I:.4f}")

# 4. Graficamos
x_cont = [Link](a, b, 200)
y_cont = f(x_cont)

[Link](x_cont, y_cont, 'b', label='f(x) = 1/√x - 2')

plt.fill_between(x_cont, y_cont, color='lightblue', alpha=0.5)
[Link](x, y, color='red', zorder=5, label='Puntos de Simpson')

[Link]('Método de Simpson 1/3')

[Link]('x')
[Link]('f(x)')
[Link]()
[Link](True)
[Link]()