Carrera de algoritmos: ¿Qué significa realmente “ganar”?
EM-4612 Métodos Numéricos — Semana MATEC 2026
Integrantes¶
- Manuel Casasola
- Mariela Núñez Guillén
- Geovanny Jiménez
Titular del grupo: Mariela Núñez Guillén
🎯 Pregunta central¶
Si varios métodos resuelven la misma ecuación, ¿es correcto afirmar que uno de ellos es simplemente “el mejor”?
En esta actividad compararemos cuatro métodos para resolver ecuaciones no lineales:
- Bisección
- Falsa posición
- Newton
- Secante
El ganador dependerá del criterio utilizado:
- Número de iteraciones.
- Evaluaciones de $f$.
- Precisión alcanzada.
- Robustez frente a cambios en los datos iniciales.
🔎 Problema base¶
Resolveremos
$$ f(x)=\cos(x)-x=0. $$
Esta ecuación tiene una raíz aproximadamente igual a
$$ x^*\approx 0.7390851332. $$
Los valores iniciales sugeridos son:
- Bisección: $[0,1]$
- Falsa posición: $[0,1]$
- Newton: $x_0=0.5$
- Secante: $x_0=0$, $x_1=1$
📌 Instrucciones¶
- Antes de ejecutar, elige cuál método crees que ganará.
- Selecciona qué significa ganar.
- Modifica los parámetros si lo deseas.
- Presiona Iniciar carrera.
- Analiza la tabla y las gráficas.
- Cambia el criterio y observa si el ganador también cambia.
Para iniciar desde una sesión limpia: seleccione Entorno de ejecución → Ejecutar todas. Antes del taller deje todas las celdas ejecutadas para que no haya tiempos muertos. Durante la presentación puede mantener plegadas las secciones de código y utilizar únicamente el panel de la carrera.
0. Preparación del entorno¶
Esta celda instala únicamente las dependencias necesarias y luego carga NumPy, Pandas, Matplotlib, Plotly, ipywidgets y la biblioteca para crear el código QR.
# ============================================================
# CARRERA DE ALGORITMOS
# Grupo 2 - Semana MATEC 2026
# ============================================================
%pip install -q ipywidgets plotly qrcode[pil] jinja2 nbformat
import math
import random
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import plotly.graph_objects as go
import plotly.io as pio
import ipywidgets as widgets
import qrcode
from IPython.display import display, clear_output, HTML, Markdown
# Habilitar widgets en Google Colab
try:
from google.colab import output
output.enable_custom_widget_manager()
pio.renderers.default = "colab"
except ImportError:
pio.renderers.default = "notebook_connected"
COLORES = {
"Bisección": "#2563EB",
"Falsa posición": "#F59E0B",
"Newton": "#DC2626",
"Secante": "#16A34A",
}
print("✅ Entorno preparado. Continúe ejecutando las celdas en orden.")
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 46.0/46.0 kB 2.4 MB/s eta 0:00:00 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.9/4.9 MB 29.9 MB/s eta 0:00:00 ✅ Entorno preparado. Continúe ejecutando las celdas en orden.
1. Función matemática del problema¶
La función y su derivada son
$$ f(x)=\cos(x)-x, \qquad f'(x)=-\sin(x)-1. $$
La raíz de referencia se utiliza únicamente para medir el error verdadero aproximado en este problema. Ninguno de los cuatro métodos recibe esa raíz para producir sus iteraciones.
# ============================================================
# 1. FUNCIÓN MATEMÁTICA DEL PROBLEMA
# ============================================================
def f(x):
"""
Función del problema:
f(x) = cos(x) - x
"""
return np.cos(x) - x
def df(x):
"""
Derivada:
f'(x) = -sin(x) - 1
"""
return -np.sin(x) - 1
# Raíz de referencia con alta precisión.
# Se usa únicamente para mostrar el error real aproximado
# en este problema específico.
RAIZ_REFERENCIA = 0.7390851332151607
print("Problema:")
print("f(x) = cos(x) - x")
print()
print(f"Raíz de referencia ≈ {RAIZ_REFERENCIA:.15f}")
Problema: f(x) = cos(x) - x Raíz de referencia ≈ 0.739085133215161
Formato común de resultados¶
Los cuatro algoritmos devolverán un diccionario con el mismo conjunto de campos. Así se pueden comparar sin ocultar la información que utiliza cada uno: estado, aproximación, iteraciones, evaluaciones de la función, evaluaciones de la derivada, residuo e historial.
def crear_resultado(
metodo,
estado,
aproximacion,
iteraciones,
evaluaciones_f,
historial,
mensaje,
evaluaciones_df=0
):
"""
Organiza la salida de todos los métodos
en un mismo formato.
El residuo final es un diagnóstico posterior; por eso su evaluación
no se agrega al costo interno del algoritmo.
"""
if aproximacion is None or not np.isfinite(aproximacion):
residuo = np.inf
error_verdadero = np.inf
else:
residuo = abs(float(f(aproximacion)))
error_verdadero = abs(float(aproximacion) - RAIZ_REFERENCIA)
return {
"metodo": metodo,
"estado": estado,
"aproximacion": aproximacion,
"iteraciones": iteraciones,
"evaluaciones_f": evaluaciones_f,
"evaluaciones_df": evaluaciones_df,
"evaluaciones_totales": evaluaciones_f + evaluaciones_df,
"residuo": residuo,
"error_verdadero": error_verdadero,
"historial": historial,
"mensaje": mensaje
}
def tabla_historial(resultado):
if len(resultado["historial"]) == 0:
print("No hay iteraciones para mostrar.")
return pd.DataFrame()
return pd.DataFrame(resultado["historial"])
2. Método de Bisección¶
El método de bisección busca una raíz de una función continua dentro de un intervalo $[a,b]$ en el que exista un cambio de signo, es decir,
$$ f(a)f(b)<0. $$
Bajo esta condición, por continuidad, existe al menos una raíz dentro del intervalo. En cada iteración se calcula el punto medio
$$ c_n=\frac{a_n+b_n}{2}. $$
Luego se evalúa $f(c_n)$.
- Si $|f(c_n)|<\mathrm{tol}$, se considera que se ha encontrado una aproximación suficientemente precisa.
- Si $f(a_n)f(c_n)<0$, la raíz se encuentra en $[a_n,c_n]$.
- En caso contrario, se conserva el intervalo $[c_n,b_n]$.
Este procedimiento se repite hasta alcanzar la tolerancia o llegar al máximo de iteraciones permitido.
Error aproximado¶
En cada iteración podemos utilizar como estimación del error
$$ E_n=\frac{|b_n-a_n|}{2}. $$
A medida que avanza el método, el intervalo que contiene la raíz se hace cada vez más pequeño.
Información que guardaremos¶
Para observar el comportamiento del algoritmo se almacenará en cada iteración
$$ n,\qquad a_n,\qquad b_n,\qquad c_n,\qquad f(c_n), $$
junto con el error aproximado. Además, contaremos la cantidad de evaluaciones de $f$, ya que este será uno de los criterios utilizados posteriormente en la carrera de algoritmos.
# ============================================================
# MÉTODO DE BISECCIÓN
# ============================================================
def biseccion(f, a, b, tol=1e-8, max_iter=100):
historial = []
evaluaciones_f = 0
c_anterior = None
if not all(np.isfinite([a, b, tol])) or tol <= 0 or max_iter < 1 or a >= b:
return crear_resultado(
"Bisección", "Datos inválidos", None, 0, 0, historial,
"Se requiere a < b, tolerancia positiva y máximo de iteraciones positivo."
)
fa = f(a)
fb = f(b)
evaluaciones_f += 2
if not np.isfinite(fa) or not np.isfinite(fb):
return crear_resultado(
"Bisección", "Dato no finito", None, 0, evaluaciones_f,
historial, "La función produjo un valor no finito en un extremo."
)
if abs(fa) < tol:
return crear_resultado(
"Bisección", "Convergió", a, 0, evaluaciones_f,
historial, "El extremo a satisface la tolerancia."
)
if abs(fb) < tol:
return crear_resultado(
"Bisección", "Convergió", b, 0, evaluaciones_f,
historial, "El extremo b satisface la tolerancia."
)
# Verificamos que exista cambio de signo
if fa * fb > 0:
return crear_resultado(
"Bisección", "Intervalo inválido", None, 0,
evaluaciones_f, historial,
"No hay cambio de signo en el intervalo."
)
c = None
for n in range(1, max_iter + 1):
# Calculamos el punto medio
c = (a + b) / 2
fc = f(c)
evaluaciones_f += 1
# Errores
error_intervalo = abs(b - a) / 2
if c_anterior is None or c == 0:
error_relativo = None
else:
error_relativo = abs((c - c_anterior) / c)
# Historial de la iteración
historial.append({
"n": n,
"a": a,
"b": b,
"x": c,
"f(x)": fc,
"residuo": abs(fc),
"error_intervalo": error_intervalo,
"error_relativo": error_relativo,
"error_verdadero": abs(c - RAIZ_REFERENCIA)
})
# Criterio de parada
if abs(fc) < tol or error_intervalo < tol:
return crear_resultado(
"Bisección", "Convergió", c, n,
evaluaciones_f, historial,
"Se alcanzó la tolerancia."
)
# Actualizamos el intervalo
if fa * fc < 0:
b = c
fb = fc
else:
a = c
fa = fc
c_anterior = c
return crear_resultado(
"Bisección", "Máximo de iteraciones", c, max_iter,
evaluaciones_f, historial,
"No se alcanzó la tolerancia."
)
# Ejemplo inicial de bisección
resultado_biseccion = biseccion(f, 0, 1)
print("Estado:", resultado_biseccion["estado"])
print("Raíz aproximada:", resultado_biseccion["aproximacion"])
print("Iteraciones:", resultado_biseccion["iteraciones"])
print("Evaluaciones de f:", resultado_biseccion["evaluaciones_f"])
print("Residuo:", resultado_biseccion["residuo"])
display(tabla_historial(resultado_biseccion))
Estado: Convergió Raíz aproximada: 0.7390851378440857 Iteraciones: 24 Evaluaciones de f: 26 Residuo: 7.747024688420368e-09
| n | a | b | x | f(x) | residuo | error_intervalo | error_relativo | error_verdadero | |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 0.000000 | 1.000000 | 0.500000 | 3.775826e-01 | 3.775826e-01 | 5.000000e-01 | NaN | 2.390851e-01 |
| 1 | 2 | 0.500000 | 1.000000 | 0.750000 | -1.831113e-02 | 1.831113e-02 | 2.500000e-01 | 3.333333e-01 | 1.091487e-02 |
| 2 | 3 | 0.500000 | 0.750000 | 0.625000 | 1.859631e-01 | 1.859631e-01 | 1.250000e-01 | 2.000000e-01 | 1.140851e-01 |
| 3 | 4 | 0.625000 | 0.750000 | 0.687500 | 8.533495e-02 | 8.533495e-02 | 6.250000e-02 | 9.090909e-02 | 5.158513e-02 |
| 4 | 5 | 0.687500 | 0.750000 | 0.718750 | 3.387937e-02 | 3.387937e-02 | 3.125000e-02 | 4.347826e-02 | 2.033513e-02 |
| 5 | 6 | 0.718750 | 0.750000 | 0.734375 | 7.874725e-03 | 7.874725e-03 | 1.562500e-02 | 2.127660e-02 | 4.710133e-03 |
| 6 | 7 | 0.734375 | 0.750000 | 0.742188 | -5.195712e-03 | 5.195712e-03 | 7.812500e-03 | 1.052632e-02 | 3.102367e-03 |
| 7 | 8 | 0.734375 | 0.742188 | 0.738281 | 1.345150e-03 | 1.345150e-03 | 3.906250e-03 | 5.291005e-03 | 8.038832e-04 |
| 8 | 9 | 0.738281 | 0.742188 | 0.740234 | -1.923873e-03 | 1.923873e-03 | 1.953125e-03 | 2.638522e-03 | 1.149242e-03 |
| 9 | 10 | 0.738281 | 0.740234 | 0.739258 | -2.890091e-04 | 2.890091e-04 | 9.765625e-04 | 1.321004e-03 | 1.726793e-04 |
| 10 | 11 | 0.738281 | 0.739258 | 0.738770 | 5.281584e-04 | 5.281584e-04 | 4.882812e-04 | 6.609385e-04 | 3.156020e-04 |
| 11 | 12 | 0.738770 | 0.739258 | 0.739014 | 1.195967e-04 | 1.195967e-04 | 2.441406e-04 | 3.303601e-04 | 7.146134e-05 |
| 12 | 13 | 0.739014 | 0.739258 | 0.739136 | -8.470073e-05 | 8.470073e-05 | 1.220703e-04 | 1.651528e-04 | 5.060897e-05 |
| 13 | 14 | 0.739014 | 0.739136 | 0.739075 | 1.744935e-05 | 1.744935e-05 | 6.103516e-05 | 8.258320e-05 | 1.042618e-05 |
| 14 | 15 | 0.739075 | 0.739136 | 0.739105 | -3.362535e-05 | 3.362535e-05 | 3.051758e-05 | 4.128990e-05 | 2.009139e-05 |
| 15 | 16 | 0.739075 | 0.739105 | 0.739090 | -8.087915e-06 | 8.087915e-06 | 1.525879e-05 | 2.064537e-05 | 4.832605e-06 |
| 16 | 17 | 0.739075 | 0.739090 | 0.739082 | 4.680737e-06 | 4.680737e-06 | 7.629395e-06 | 1.032279e-05 | 2.796789e-06 |
| 17 | 18 | 0.739082 | 0.739090 | 0.739086 | -1.703583e-06 | 1.703583e-06 | 3.814697e-06 | 5.161370e-06 | 1.017908e-06 |
| 18 | 19 | 0.739082 | 0.739086 | 0.739084 | 1.488578e-06 | 1.488578e-06 | 1.907349e-06 | 2.580692e-06 | 8.894407e-07 |
| 19 | 20 | 0.739084 | 0.739086 | 0.739085 | -1.075021e-07 | 1.075021e-07 | 9.536743e-07 | 1.290344e-06 | 6.423357e-08 |
| 20 | 21 | 0.739084 | 0.739085 | 0.739085 | 6.905383e-07 | 6.905383e-07 | 4.768372e-07 | 6.451725e-07 | 4.126036e-07 |
| 21 | 22 | 0.739085 | 0.739085 | 0.739085 | 2.915181e-07 | 2.915181e-07 | 2.384186e-07 | 3.225862e-07 | 1.741850e-07 |
| 22 | 23 | 0.739085 | 0.739085 | 0.739085 | 9.200802e-08 | 9.200802e-08 | 1.192093e-07 | 1.612931e-07 | 5.497572e-08 |
| 23 | 24 | 0.739085 | 0.739085 | 0.739085 | -7.747025e-09 | 7.747025e-09 | 5.960464e-08 | 8.064652e-08 | 4.628925e-09 |
3. Método de Falsa Posición¶
El método de falsa posición, también conocido como Regla Falsa, es un método numérico para aproximar raíces de una función continua.
Al igual que el método de bisección, parte de un intervalo $[a,b]$ en el cual existe un cambio de signo:
$$ f(a)f(b)<0. $$
Esta condición indica que, si $f$ es continua, existe al menos una raíz dentro del intervalo.
La diferencia con bisección es que no se utiliza el punto medio. En su lugar, se traza una recta secante entre los puntos $(a,f(a))$ y $(b,f(b))$. La intersección de esta recta con el eje $x$ se utiliza como la nueva aproximación de la raíz.
La fórmula es
$$ c=\frac{af(b)-bf(a)}{f(b)-f(a)}. $$
También puede escribirse como
$$ c=b-f(b)\frac{b-a}{f(b)-f(a)}. $$
Luego se evalúa $f(c)$.
- Si $|f(c)|<\mathrm{tol}$, se considera que se alcanzó una aproximación suficientemente precisa.
- Si $f(a)f(c)<0$, se conserva el intervalo $[a,c]$.
- En caso contrario, se conserva el intervalo $[c,b]$.
El proceso continúa hasta alcanzar la tolerancia o llegar al máximo de iteraciones permitido.
Idea principal¶
A diferencia de bisección, que siempre toma el punto medio, falsa posición utiliza los valores de la función en los extremos para construir una aproximación mediante interpolación lineal. Esto puede hacer que la aproximación se acerque más rápidamente a la raíz en algunos problemas.
Información que guardaremos¶
En cada iteración almacenaremos
$$ n,\qquad a_n,\qquad b_n,\qquad c_n,\qquad f(c_n), $$
además de una medida del error y el número de evaluaciones de $f$. Esta información permitirá comparar posteriormente el método de falsa posición con bisección, Newton y secante.
Ejemplo inicial¶
Consideremos nuevamente $f(x)=\cos(x)-x$ en el intervalo $[0,1]$.
Evaluamos:
$$ f(0)=1, \qquad f(1)=\cos(1)-1\approx -0.4597. $$
Como $f(0)f(1)<0$, podemos aplicar el método. La primera aproximación se obtiene mediante
$$ c_1=\frac{0\cdot f(1)-1\cdot f(0)}{f(1)-f(0)}\approx 0.6851. $$
Luego evaluamos $f(c_1)$. Como el valor todavía no satisface la tolerancia, se conserva el subintervalo donde permanece el cambio de signo y se repite el procedimiento. A diferencia de bisección, la aproximación no tiene que ser el punto medio del intervalo.
# ============================================================
# MÉTODO DE FALSA POSICIÓN
# ============================================================
def falsa_posicion(f, a, b, tol=1e-8, max_iter=100):
historial = []
evaluaciones_f = 0
if not all(np.isfinite([a, b, tol])) or tol <= 0 or max_iter < 1 or a >= b:
return crear_resultado(
"Falsa posición", "Datos inválidos", None, 0, 0, historial,
"Se requiere a < b, tolerancia positiva y máximo de iteraciones positivo."
)
fa = f(a)
fb = f(b)
evaluaciones_f += 2
if not np.isfinite(fa) or not np.isfinite(fb):
return crear_resultado(
"Falsa posición", "Dato no finito", None, 0,
evaluaciones_f, historial,
"La función produjo un valor no finito en un extremo."
)
if abs(fa) < tol:
return crear_resultado(
"Falsa posición", "Convergió", a, 0, evaluaciones_f,
historial, "El extremo a satisface la tolerancia."
)
if abs(fb) < tol:
return crear_resultado(
"Falsa posición", "Convergió", b, 0, evaluaciones_f,
historial, "El extremo b satisface la tolerancia."
)
# Debe existir cambio de signo en el intervalo
if fa * fb > 0:
return crear_resultado(
"Falsa posición", "Intervalo inválido", None, 0,
evaluaciones_f, historial,
"No hay cambio de signo en el intervalo."
)
c = None
for n in range(1, max_iter + 1):
# Evita una división entre un número muy pequeño
if abs(fb - fa) < 1e-14:
return crear_resultado(
"Falsa posición", "División problemática", c, n - 1,
evaluaciones_f, historial,
"El denominador es demasiado pequeño."
)
# Punto donde la secante corta el eje x
c = (a * fb - b * fa) / (fb - fa)
fc = f(c)
evaluaciones_f += 1
if not np.isfinite(fc) or abs(c) > 1e12:
return crear_resultado(
"Falsa posición", "Divergencia evidente", c, n,
evaluaciones_f, historial,
"La iteración produjo un valor no finito o excesivamente grande."
)
# Guardamos la información de la iteración
historial.append({
"n": n,
"a": a,
"b": b,
"x": c,
"f(x)": fc,
"residuo": abs(fc),
"error": abs(fc),
"error_verdadero": abs(c - RAIZ_REFERENCIA)
})
# Criterio de parada
if abs(fc) < tol:
return crear_resultado(
"Falsa posición", "Convergió", c, n,
evaluaciones_f, historial,
"Se alcanzó la tolerancia."
)
# Conservamos el intervalo donde hay cambio de signo
if fa * fc < 0:
b = c
fb = fc
else:
a = c
fa = fc
return crear_resultado(
"Falsa posición", "Máximo de iteraciones", c, max_iter,
evaluaciones_f, historial,
"No se alcanzó la tolerancia."
)
# Ejemplo inicial de falsa posición
resultado_falsa_posicion = falsa_posicion(f, 0, 1)
print("Estado:", resultado_falsa_posicion["estado"])
print("Raíz aproximada:", resultado_falsa_posicion["aproximacion"])
print("Iteraciones:", resultado_falsa_posicion["iteraciones"])
print("Evaluaciones de f:", resultado_falsa_posicion["evaluaciones_f"])
print("Residuo:", resultado_falsa_posicion["residuo"])
display(tabla_historial(resultado_falsa_posicion))
Estado: Convergió Raíz aproximada: 0.7390851323349952 Iteraciones: 7 Evaluaciones de f: 9 Residuo: 1.4730554553921138e-09
| n | a | b | x | f(x) | residuo | error | error_verdadero | |
|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 0.000000 | 1 | 0.685073 | 8.929928e-02 | 8.929928e-02 | 8.929928e-02 | 5.401178e-02 |
| 1 | 2 | 0.685073 | 1 | 0.736299 | 4.660039e-03 | 4.660039e-03 | 4.660039e-03 | 2.786136e-03 |
| 2 | 3 | 0.736299 | 1 | 0.738945 | 2.339257e-04 | 2.339257e-04 | 2.339257e-04 | 1.397772e-04 |
| 3 | 4 | 0.738945 | 1 | 0.739078 | 1.171917e-05 | 1.171917e-05 | 1.171917e-05 | 7.002335e-06 |
| 4 | 5 | 0.739078 | 1 | 0.739085 | 5.870465e-07 | 5.870465e-07 | 5.870465e-07 | 3.507662e-07 |
| 5 | 6 | 0.739085 | 1 | 0.739085 | 2.940667e-08 | 2.940667e-08 | 2.940667e-08 | 1.757078e-08 |
| 6 | 7 | 0.739085 | 1 | 0.739085 | 1.473055e-09 | 1.473055e-09 | 1.473055e-09 | 8.801655e-10 |
4. Método de Newton¶
El método de Newton, también conocido como Newton-Raphson, es un método iterativo para aproximar raíces de una ecuación no lineal $f(x)=0$.
A diferencia de Bisección y Falsa Posición, no necesita comenzar con un intervalo que encierre una raíz. En su lugar, parte de una aproximación inicial $x_0$ y utiliza la recta tangente a la función para construir nuevas aproximaciones.
Fórmula del método¶
Si conocemos una aproximación $x_n$, la siguiente se calcula mediante
$$ x_{n+1}=x_n-\frac{f(x_n)}{f'(x_n)}. $$
La idea geométrica es trazar la recta tangente a la gráfica de $f$ en el punto $(x_n,f(x_n))$. El punto donde esa recta tangente corta el eje $x$ se toma como la siguiente aproximación $x_{n+1}$.
Procedimiento¶
En cada iteración se realiza lo siguiente:
- Evaluar la función en la aproximación actual: $f(x_n)$.
- Evaluar la derivada: $f'(x_n)$.
- Calcular la nueva aproximación: $x_{n+1}=x_n-\dfrac{f(x_n)}{f'(x_n)}$.
- Calcular el cambio entre aproximaciones: $E_n=|x_{n+1}-x_n|$.
- Evaluar si se alcanzó la tolerancia. En nuestro código utilizamos como criterio principal $|f(x_{n+1})|<\mathrm{tol}$.
Si esta condición se cumple, se considera que el método ha convergido.
Caso problemático: derivada cercana a cero¶
La fórmula de Newton contiene una división entre $f'(x_n)$. Por esta razón, si $f'(x_n)\approx 0$, la división puede producir un valor demasiado grande o numéricamente inestable. En el programa se verifica esta situación antes de realizar la actualización. Si $|f'(x_n)|<10^{-12}$, el algoritmo se detiene y reporta un estado de derivada problemática.
Información que guardaremos¶
En cada iteración se almacenará información como
$$ n,\qquad x_n,\qquad x_{n+1},\qquad f(x_{n+1}),\qquad f'(x_n), $$
junto con el error aproximado $|x_{n+1}-x_n|$.
También se contará por separado:
- el número de evaluaciones de $f$;
- el número de evaluaciones de $f'$.
Esto es importante para la carrera de algoritmos, ya que Newton puede requerir pocas iteraciones, pero utiliza más información en cada paso que otros métodos.
Ventajas y consideraciones¶
Una de las principales ventajas del método de Newton es que puede converger muy rápidamente cuando el valor inicial está suficientemente cerca de una raíz simple.
Sin embargo, su comportamiento depende del valor inicial $x_0$ y del comportamiento de la derivada.
Por esta razón, un número pequeño de iteraciones no implica necesariamente que Newton sea siempre el mejor método.
En la carrera de algoritmos compararemos este comportamiento con Bisección, Falsa Posición y Secante utilizando distintos criterios de desempeño.
# ============================================================
# MÉTODO DE NEWTON
# ============================================================
def newton(f, df, x0, tol=1e-8, max_iter=100):
historial = []
evaluaciones_f = 0
evaluaciones_df = 0
if not all(np.isfinite([x0, tol])) or tol <= 0 or max_iter < 1:
return crear_resultado(
"Newton", "Datos inválidos", None, 0, 0, historial,
"Se requiere un valor inicial finito, tolerancia positiva y máximo de iteraciones positivo."
)
x = float(x0)
for n in range(1, max_iter + 1):
# Evaluamos la función y su derivada
fx = f(x)
dfx = df(x)
evaluaciones_f += 1
evaluaciones_df += 1
if not np.isfinite(fx) or not np.isfinite(dfx):
return crear_resultado(
"Newton", "Dato no finito", x, n - 1,
evaluaciones_f, historial,
"La función o su derivada produjo un valor no finito.",
evaluaciones_df
)
# Evitamos dividir entre una derivada muy pequeña
if abs(dfx) < 1e-12:
return crear_resultado(
"Newton", "Derivada problemática", x, n - 1,
evaluaciones_f, historial,
"La derivada es demasiado cercana a cero.",
evaluaciones_df
)
# Fórmula de Newton
x_nuevo = x - fx / dfx
# Evaluamos la función en la nueva aproximación
fx_nuevo = f(x_nuevo)
evaluaciones_f += 1
# Error aproximado entre iteraciones
error = abs(x_nuevo - x)
if not np.isfinite(x_nuevo) or not np.isfinite(fx_nuevo) or abs(x_nuevo) > 1e12:
return crear_resultado(
"Newton", "Divergencia evidente", x_nuevo, n,
evaluaciones_f, historial,
"La iteración produjo un valor no finito o excesivamente grande.",
evaluaciones_df
)
# Guardamos la información de la iteración
historial.append({
"n": n,
"x_anterior": x,
"x": x_nuevo,
"f(x)": fx_nuevo,
"f'(x_anterior)": dfx,
"residuo": abs(fx_nuevo),
"error": error,
"error_verdadero": abs(x_nuevo - RAIZ_REFERENCIA)
})
# Criterio de parada
if abs(fx_nuevo) < tol:
return crear_resultado(
"Newton", "Convergió", x_nuevo, n,
evaluaciones_f, historial,
"Se alcanzó la tolerancia.",
evaluaciones_df
)
# Actualizamos la aproximación
x = x_nuevo
return crear_resultado(
"Newton", "Máximo de iteraciones", x, max_iter,
evaluaciones_f, historial,
"No se alcanzó la tolerancia.",
evaluaciones_df
)
# Ejemplo inicial de Newton
resultado_newton = newton(f, df, 0.5)
print("Estado:", resultado_newton["estado"])
print("Raíz aproximada:", resultado_newton["aproximacion"])
print("Iteraciones:", resultado_newton["iteraciones"])
print("Evaluaciones de f:", resultado_newton["evaluaciones_f"])
print("Evaluaciones de f':", resultado_newton["evaluaciones_df"])
print("Residuo:", resultado_newton["residuo"])
display(tabla_historial(resultado_newton))
Estado: Convergió Raíz aproximada: 0.7390851339208068 Iteraciones: 3 Evaluaciones de f: 6 Evaluaciones de f': 3 Residuo: 1.1809778710514252e-09
| n | x_anterior | x | f(x) | f'(x_anterior) | residuo | error | error_verdadero | |
|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 0.500000 | 0.755222 | -2.710331e-02 | -1.479426 | 2.710331e-02 | 0.255222 | 1.613728e-02 |
| 1 | 2 | 0.755222 | 0.739142 | -9.461538e-05 | -1.685451 | 9.461538e-05 | 0.016081 | 5.653293e-05 |
| 2 | 3 | 0.739142 | 0.739085 | -1.180978e-09 | -1.673654 | 1.180978e-09 | 0.000057 | 7.056461e-10 |
5. Método de la Secante¶
El método de la secante es un método abierto para aproximar una raíz de $f(x)=0$. Parte de dos aproximaciones iniciales, $x_0$ y $x_1$, pero no exige que formen un intervalo con cambio de signo.
Su idea se parece a la de falsa posición: se construye una recta secante por los puntos $(x_{n-1},f(x_{n-1}))$ y $(x_n,f(x_n))$. Sin embargo, secante conserva las dos aproximaciones más recientes y no necesariamente mantiene la raíz encerrada.
Fórmula del método¶
La intersección de esa recta con el eje $x$ produce
$$ x_{n+1} =x_n-f(x_n)\frac{x_n-x_{n-1}}{f(x_n)-f(x_{n-1})}. $$
Procedimiento paso a paso¶
- Evaluar $f(x_{n-1})$ y $f(x_n)$.
- Verificar que $f(x_n)-f(x_{n-1})$ no sea demasiado cercano a cero.
- Calcular $x_{n+1}$ mediante la fórmula de la secante.
- Calcular el error aproximado $E_n=|x_{n+1}-x_n|$.
- Detener el proceso si $|f(x_{n+1})|<\mathrm{tol}$; de lo contrario, reemplazar $x_{n-1}$ por $x_n$ y $x_n$ por $x_{n+1}$.
Diferencia con Newton¶
Newton utiliza la derivada exacta $f'(x_n)$. Secante reemplaza esa derivada por la pendiente aproximada
$$ \frac{f(x_n)-f(x_{n-1})}{x_n-x_{n-1}}. $$
Por eso secante no cuenta evaluaciones de $f'$. Puede ser más económica cuando calcular la derivada es difícil, aunque generalmente ofrece menos garantías que un método acotado.
Información que guardaremos¶
En cada iteración se almacenará
$$ n,\qquad x_{n-1},\qquad x_n,\qquad x_{n+1},\qquad f(x_{n-1}),\qquad f(x_n),\qquad f(x_{n+1}), $$
junto con $|x_{n+1}-x_n|$ y el conteo acumulado de evaluaciones de $f$.
# ============================================================
# MÉTODO DE LA SECANTE
# ============================================================
def secante(f, x0, x1, tol=1e-8, max_iter=100):
historial = []
evaluaciones_f = 0
if not all(np.isfinite([x0, x1, tol])) or tol <= 0 or max_iter < 1:
return crear_resultado(
"Secante", "Datos inválidos", None, 0, 0, historial,
"Se requieren valores iniciales finitos, tolerancia positiva y máximo de iteraciones positivo."
)
x_anterior = float(x0)
x_actual = float(x1)
f_anterior = f(x_anterior)
f_actual = f(x_actual)
evaluaciones_f += 2
if not np.isfinite(f_anterior) or not np.isfinite(f_actual):
return crear_resultado(
"Secante", "Dato no finito", None, 0, evaluaciones_f,
historial, "La función produjo un valor no finito."
)
if abs(f_anterior) < tol:
return crear_resultado(
"Secante", "Convergió", x_anterior, 0, evaluaciones_f,
historial, "El valor inicial x0 satisface la tolerancia."
)
if abs(f_actual) < tol:
return crear_resultado(
"Secante", "Convergió", x_actual, 0, evaluaciones_f,
historial, "El valor inicial x1 satisface la tolerancia."
)
x_nuevo = None
for n in range(1, max_iter + 1):
denominador = f_actual - f_anterior
if abs(denominador) < 1e-14:
return crear_resultado(
"Secante", "División problemática", x_actual, n - 1,
evaluaciones_f, historial,
"Las evaluaciones consecutivas son demasiado parecidas."
)
x_nuevo = x_actual - f_actual * (x_actual - x_anterior) / denominador
f_nuevo = f(x_nuevo)
evaluaciones_f += 1
error = abs(x_nuevo - x_actual)
if not np.isfinite(x_nuevo) or not np.isfinite(f_nuevo) or abs(x_nuevo) > 1e12:
return crear_resultado(
"Secante", "Divergencia evidente", x_nuevo, n,
evaluaciones_f, historial,
"La iteración produjo un valor no finito o excesivamente grande."
)
historial.append({
"n": n,
"x_anterior": x_anterior,
"x_actual": x_actual,
"x": x_nuevo,
"f(x_anterior)": f_anterior,
"f(x_actual)": f_actual,
"f(x)": f_nuevo,
"residuo": abs(f_nuevo),
"error": error,
"error_verdadero": abs(x_nuevo - RAIZ_REFERENCIA)
})
if abs(f_nuevo) < tol:
return crear_resultado(
"Secante", "Convergió", x_nuevo, n,
evaluaciones_f, historial,
"Se alcanzó la tolerancia."
)
x_anterior, x_actual = x_actual, x_nuevo
f_anterior, f_actual = f_actual, f_nuevo
return crear_resultado(
"Secante", "Máximo de iteraciones", x_nuevo, max_iter,
evaluaciones_f, historial,
"No se alcanzó la tolerancia."
)
# Ejemplo inicial de secante
resultado_secante = secante(f, 0, 1)
print("Estado:", resultado_secante["estado"])
print("Raíz aproximada:", resultado_secante["aproximacion"])
print("Iteraciones:", resultado_secante["iteraciones"])
print("Evaluaciones de f:", resultado_secante["evaluaciones_f"])
print("Residuo:", resultado_secante["residuo"])
display(tabla_historial(resultado_secante))
Estado: Convergió Raíz aproximada: 0.7390851332150012 Iteraciones: 5 Evaluaciones de f: 7 Residuo: 2.667865928174251e-13
| n | x_anterior | x_actual | x | f(x_anterior) | f(x_actual) | f(x) | residuo | error | error_verdadero | |
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 0.000000 | 1.000000 | 0.685073 | 1.000000 | -4.596977e-01 | 8.929928e-02 | 8.929928e-02 | 3.149266e-01 | 5.401178e-02 |
| 1 | 2 | 1.000000 | 0.685073 | 0.736299 | -0.459698 | 8.929928e-02 | 4.660039e-03 | 4.660039e-03 | 5.122564e-02 | 2.786136e-03 |
| 2 | 3 | 0.685073 | 0.736299 | 0.739119 | 0.089299 | 4.660039e-03 | -5.728599e-05 | 5.728599e-05 | 2.820364e-03 | 3.422870e-05 |
| 3 | 4 | 0.736299 | 0.739119 | 0.739085 | 0.004660 | -5.728599e-05 | 3.529262e-08 | 3.529262e-08 | 3.424978e-05 | 2.108770e-08 |
| 4 | 5 | 0.739119 | 0.739085 | 0.739085 | -0.000057 | 3.529262e-08 | 2.667866e-13 | 2.667866e-13 | 2.108754e-08 | 1.594280e-13 |
6. Motor común de la carrera¶
Para evitar comparaciones engañosas, todos los métodos reciben la misma tolerancia y el mismo máximo de iteraciones. La tabla distingue evaluaciones de $f$ y evaluaciones de $f'$. También muestra dos medidas diferentes:
- Residuo: $|f(x_n)|$. Indica qué tan bien satisface la aproximación la ecuación.
- Error verdadero aproximado: $|x_n-x^*|$. Solo puede calcularse aquí porque disponemos de una raíz de referencia.
El criterio de robustez es experimental: se repite cada algoritmo con nueve desplazamientos de sus datos iniciales. Para los métodos acotados se desplaza el intervalo completo; para Newton se desplaza $x_0$; para secante se desplazan ambos valores iniciales. El porcentaje obtenido no constituye una garantía general.
NOMBRES_METODOS = ["Bisección", "Falsa posición", "Newton", "Secante"]
def ejecutar_todos(a, b, x0_newton, x0_secante, x1_secante, tol, max_iter):
"""Ejecuta los cuatro métodos con una configuración común."""
if tol <= 0:
raise ValueError("La tolerancia debe ser positiva.")
if max_iter < 1:
raise ValueError("El máximo de iteraciones debe ser positivo.")
resultados = {
"Bisección": biseccion(f, a, b, tol, max_iter),
"Falsa posición": falsa_posicion(f, a, b, tol, max_iter),
"Newton": newton(f, df, x0_newton, tol, max_iter),
"Secante": secante(f, x0_secante, x1_secante, tol, max_iter),
}
return resultados
def evaluar_robustez(parametros, amplitud=0.40, cantidad=9):
"""
Estudio empírico de sensibilidad ante desplazamientos simétricos
de los datos iniciales. Devuelve tasa de éxito y detalle de estados.
"""
desplazamientos = np.linspace(-amplitud, amplitud, cantidad)
estados = {nombre: [] for nombre in NOMBRES_METODOS}
for delta in desplazamientos:
pruebas = ejecutar_todos(
parametros["a"] + delta,
parametros["b"] + delta,
parametros["x0_newton"] + delta,
parametros["x0_secante"] + delta,
parametros["x1_secante"] + delta,
parametros["tol"],
parametros["max_iter"],
)
for nombre, resultado in pruebas.items():
estados[nombre].append(resultado["estado"])
resumen = {}
for nombre in NOMBRES_METODOS:
exitos = sum(estado == "Convergió" for estado in estados[nombre])
resumen[nombre] = {
"robustez": 100 * exitos / cantidad,
"exitos": exitos,
"pruebas": cantidad,
"estados": estados[nombre],
}
return resumen
def construir_resumen(resultados, robustez):
filas = []
for nombre in NOMBRES_METODOS:
r = resultados[nombre]
filas.append({
"Método": nombre,
"Estado": r["estado"],
"Aproximación": r["aproximacion"],
"Iteraciones": r["iteraciones"],
"Eval. f": r["evaluaciones_f"],
"Eval. f'": r["evaluaciones_df"],
"Eval. totales": r["evaluaciones_totales"],
"|f(x)|": r["residuo"],
"|x - x*|": r["error_verdadero"],
"Robustez empírica": robustez[nombre]["robustez"],
})
return pd.DataFrame(filas)
CRITERIOS = {
"iteraciones": ("iteraciones", "min"),
"evaluaciones_f": ("evaluaciones_f", "min"),
"evaluaciones_totales": ("evaluaciones_totales", "min"),
"precision": ("error_verdadero", "min"),
"robustez": ("robustez", "max"),
}
def determinar_ganadores(resultados, robustez, criterio):
"""Devuelve todos los ganadores; conserva empates numéricos."""
if criterio == "robustez":
valores = {n: robustez[n]["robustez"] for n in NOMBRES_METODOS}
mejor = max(valores.values())
return [n for n, v in valores.items() if np.isclose(v, mejor)]
llave, _ = CRITERIOS[criterio]
candidatos = {
n: r for n, r in resultados.items()
if r["estado"] == "Convergió" and np.isfinite(r[llave])
}
if not candidatos:
return []
mejor = min(r[llave] for r in candidatos.values())
return [n for n, r in candidatos.items() if np.isclose(r[llave], mejor, rtol=1e-10, atol=1e-15)]
def explicacion_criterio(criterio):
textos = {
"iteraciones": (
"Se premia el menor número de actualizaciones. Este criterio no mide "
"cuánto cuesta cada actualización ni la información adicional utilizada."
),
"evaluaciones_f": (
"Se cuentan únicamente las evaluaciones de f. Para Newton deben observarse "
"también las evaluaciones de f', que aparecen en una columna separada."
),
"evaluaciones_totales": (
"Se suma una unidad por cada evaluación de f y de f'. Es una comparación "
"transparente, aunque supone que ambas evaluaciones cuestan lo mismo."
),
"precision": (
"Se premia el menor |x-x*|. Este criterio depende de disponer de una raíz "
"de referencia y del efecto de la regla de parada y del redondeo."
),
"robustez": (
"Se premia la mayor proporción de convergencias en nueve perturbaciones. "
"Es evidencia experimental para estos casos, no una demostración general."
),
}
return textos[criterio]
7. Visualizaciones de la carrera¶
La primera figura es una carrera animada: cada cuadro añade una iteración y el eje vertical usa escala logarítmica. La segunda figura muestra la función y las aproximaciones producidas; puede ocultar o mostrar métodos pulsando sus nombres en la leyenda.
def serie_historial(resultado, metrica="residuo"):
historial = resultado["historial"]
x_iter = [fila["n"] for fila in historial]
y = [max(float(fila[metrica]), np.finfo(float).tiny) for fila in historial]
return x_iter, y
def crear_figura_carrera(resultados, metrica="residuo"):
etiqueta_y = "|f(xₙ)|" if metrica == "residuo" else "|xₙ - x*|"
series = {n: serie_historial(r, metrica) for n, r in resultados.items()}
max_pasos = max([len(x) for x, _ in series.values()] + [1])
def datos_hasta(paso):
datos = []
for nombre in NOMBRES_METODOS:
xs, ys = series[nombre]
limite = min(paso, len(xs))
datos.append(go.Scatter(
x=xs[:limite],
y=ys[:limite],
mode="lines+markers",
name=nombre,
line=dict(color=COLORES[nombre], width=4),
marker=dict(size=8),
hovertemplate=(
f"<b>{nombre}</b><br>Iteración %{{x}}<br>"
+ etiqueta_y + " = %{y:.3e}<extra></extra>"
),
))
return datos
frames = [
go.Frame(data=datos_hasta(k), name=str(k))
for k in range(1, max_pasos + 1)
]
fig = go.Figure(data=datos_hasta(1), frames=frames)
pasos = [{
"method": "animate",
"label": str(k),
"args": [[str(k)], {
"mode": "immediate",
"frame": {"duration": 350, "redraw": True},
"transition": {"duration": 150},
}],
} for k in range(1, max_pasos + 1)]
fig.update_layout(
title="Carrera animada del error por iteración",
template="plotly_white",
height=520,
xaxis=dict(title="Iteración", dtick=1, rangemode="tozero"),
yaxis=dict(title=etiqueta_y, type="log"),
hovermode="x unified",
legend=dict(orientation="h", y=1.12, x=0),
margin=dict(l=60, r=30, t=100, b=80),
updatemenus=[{
"type": "buttons",
"direction": "left",
"x": 0,
"y": -0.18,
"buttons": [
{"label": "▶ Reproducir", "method": "animate",
"args": [None, {"frame": {"duration": 500, "redraw": True},
"fromcurrent": True,
"transition": {"duration": 180}}]},
{"label": "⏸ Pausar", "method": "animate",
"args": [[None], {"mode": "immediate",
"frame": {"duration": 0, "redraw": False},
"transition": {"duration": 0}}]},
],
}],
sliders=[{
"active": 0,
"currentvalue": {"prefix": "Iteración mostrada: "},
"pad": {"t": 55},
"steps": pasos,
}],
)
return fig
def crear_figura_geometrica(resultados):
aproximaciones = [
fila["x"]
for resultado in resultados.values()
for fila in resultado["historial"]
if np.isfinite(fila["x"])
]
if aproximaciones:
minimo = max(-5, min(aproximaciones + [-0.2]) - 0.25)
maximo = min(5, max(aproximaciones + [1.2]) + 0.25)
else:
minimo, maximo = -0.2, 1.2
xx = np.linspace(minimo, maximo, 500)
fig = go.Figure()
fig.add_trace(go.Scatter(
x=xx, y=f(xx), mode="lines", name="f(x)=cos(x)-x",
line=dict(color="#111827", width=3)
))
fig.add_hline(y=0, line_color="#64748B", line_width=1)
fig.add_vline(x=RAIZ_REFERENCIA, line_dash="dash", line_color="#7C3AED",
annotation_text="x*", annotation_position="top")
for nombre in NOMBRES_METODOS:
hist = resultados[nombre]["historial"]
xs = [fila["x"] for fila in hist]
ys = [fila["f(x)"] for fila in hist]
ns = [fila["n"] for fila in hist]
fig.add_trace(go.Scatter(
x=xs, y=ys, mode="markers+lines", name=nombre,
marker=dict(size=8, color=COLORES[nombre]),
line=dict(color=COLORES[nombre], width=2, dash="dot"),
customdata=ns,
hovertemplate=(
f"<b>{nombre}</b><br>n=%{{customdata}}<br>"
"x=%{x:.10f}<br>f(x)=%{y:.3e}<extra></extra>"
),
))
fig.update_layout(
title="Aproximaciones sobre la gráfica de f",
template="plotly_white",
height=470,
xaxis_title="x",
yaxis_title="f(x)",
legend=dict(orientation="h", y=1.14, x=0),
margin=dict(l=60, r=30, t=95, b=55),
)
return fig
def graficar_respaldo_estatico(resultados, metrica="residuo"):
"""Respaldo visual sencillo si la interacción de Plotly no estuviera disponible."""
etiqueta = r"$|f(x_n)|$" if metrica == "residuo" else r"$|x_n-x^*|$"
fig, ax = plt.subplots(figsize=(10, 5.5))
for nombre in NOMBRES_METODOS:
xs, ys = serie_historial(resultados[nombre], metrica)
if xs:
ax.semilogy(xs, ys, marker="o", linewidth=2.4,
label=nombre, color=COLORES[nombre])
ax.set_title("Respaldo estático de la carrera")
ax.set_xlabel("Iteración")
ax.set_ylabel(etiqueta)
ax.grid(True, which="both", alpha=0.25)
ax.legend()
plt.tight_layout()
plt.show()
8. Resultado base guardable como respaldo¶
Esta ejecución automática permite conservar una tabla y una figura representativas dentro del cuaderno. La interfaz pública aparece en la sección siguiente.
PARAMETROS_BASE = {
"a": 0.0,
"b": 1.0,
"x0_newton": 0.5,
"x0_secante": 0.0,
"x1_secante": 1.0,
"tol": 1e-8,
"max_iter": 50,
}
resultados_base = ejecutar_todos(**PARAMETROS_BASE)
robustez_base = evaluar_robustez(PARAMETROS_BASE, amplitud=0.40, cantidad=9)
tabla_base = construir_resumen(resultados_base, robustez_base)
display(
tabla_base.style
.format({
"Aproximación": "{:.12g}",
"|f(x)|": "{:.3e}",
"|x - x*|": "{:.3e}",
"Robustez empírica": "{:.0f}%",
}, na_rep="—")
.background_gradient(subset=["Iteraciones"], cmap="Blues_r")
)
graficar_respaldo_estatico(resultados_base)
| Método | Estado | Aproximación | Iteraciones | Eval. f | Eval. f' | Eval. totales | |f(x)| | |x - x*| | Robustez empírica | |
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | Bisección | Convergió | 0.739085137844 | 24 | 26 | 0 | 26 | 7.747e-09 | 4.629e-09 | 78% |
| 1 | Falsa posición | Convergió | 0.739085132335 | 7 | 9 | 0 | 9 | 1.473e-09 | 8.802e-10 | 78% |
| 2 | Newton | Convergió | 0.739085133921 | 3 | 6 | 3 | 9 | 1.181e-09 | 7.056e-10 | 100% |
| 3 | Secante | Convergió | 0.739085133215 | 5 | 7 | 0 | 7 | 2.668e-13 | 1.594e-13 | 100% |
9. Panel interactivo para el público¶
El patrón de trabajo es
$$ \text{predecir}\longrightarrow\text{decidir}\longrightarrow \text{ejecutar}\longrightarrow\text{observar}\longrightarrow \text{explicar}\longrightarrow\text{modificar y volver a probar}. $$
La interfaz exige una predicción antes de correr. Después permite cambiar el significado de “ganar” sin modificar los resultados numéricos ya obtenidos.
# ============================================================
# INTERFAZ INTERACTIVA DE LA CARRERA
# ============================================================
ESCENARIOS = {
"Caso base recomendado": {
"descripcion": "Datos razonables indicados en la guía de la actividad.",
"a": 0.0, "b": 1.0, "x0_newton": 0.5,
"x0_secante": 0.0, "x1_secante": 1.0,
},
"Intervalo más amplio": {
"descripcion": "La raíz sigue encerrada, pero los métodos comienzan más lejos.",
"a": -2.0, "b": 2.0, "x0_newton": 2.0,
"x0_secante": -2.0, "x1_secante": 2.0,
},
"Newton cerca de derivada cero": {
"descripcion": "Newton inicia en -π/2, donde f'(x)=0; los demás conservan datos base.",
"a": 0.0, "b": 1.0, "x0_newton": -math.pi / 2,
"x0_secante": 0.0, "x1_secante": 1.0,
},
"Secante con datos repetidos": {
"descripcion": "Secante recibe dos valores iguales y debe reportar una división problemática.",
"a": 0.0, "b": 1.0, "x0_newton": 0.5,
"x0_secante": 0.5, "x1_secante": 0.5,
},
}
selector_escenario = widgets.Dropdown(
options=list(ESCENARIOS), value="Caso base recomendado",
description="Escenario:", style={"description_width": "95px"},
layout=widgets.Layout(width="480px")
)
descripcion_escenario = widgets.HTML()
prediccion = widgets.Dropdown(
options=[("— Elige antes de correr —", None)] + [(n, n) for n in NOMBRES_METODOS],
value=None, description="Predicción:",
style={"description_width": "95px"}, layout=widgets.Layout(width="320px")
)
criterio = widgets.Dropdown(
options=[
("Menos iteraciones", "iteraciones"),
("Menos evaluaciones de f", "evaluaciones_f"),
("Menos evaluaciones totales", "evaluaciones_totales"),
("Mayor precisión", "precision"),
("Mayor robustez empírica", "robustez"),
],
value="iteraciones", description="Ganar =",
style={"description_width": "95px"}, layout=widgets.Layout(width="350px")
)
metrica_grafica = widgets.ToggleButtons(
options=[("Residuo |f(xₙ)|", "residuo"), ("Error |xₙ-x*|", "error_verdadero")],
value="residuo", description="Gráfica:",
style={"description_width": "70px"}
)
a_widget = widgets.FloatText(value=0.0, description="a:", layout=widgets.Layout(width="190px"))
b_widget = widgets.FloatText(value=1.0, description="b:", layout=widgets.Layout(width="190px"))
x0_newton_widget = widgets.FloatText(value=0.5, description="Newton x₀:",
style={"description_width": "85px"},
layout=widgets.Layout(width="220px"))
x0_secante_widget = widgets.FloatText(value=0.0, description="Secante x₀:",
style={"description_width": "85px"},
layout=widgets.Layout(width="220px"))
x1_secante_widget = widgets.FloatText(value=1.0, description="Secante x₁:",
style={"description_width": "85px"},
layout=widgets.Layout(width="220px"))
tol_widget = widgets.SelectionSlider(
options=[("10⁻⁴", 1e-4), ("10⁻⁶", 1e-6), ("10⁻⁸", 1e-8), ("10⁻¹⁰", 1e-10)],
value=1e-8, description="Tolerancia:", continuous_update=False,
style={"description_width": "90px"}, layout=widgets.Layout(width="390px")
)
max_iter_widget = widgets.IntSlider(
value=50, min=1, max=100, step=1, description="Máx. iter.:",
continuous_update=False, style={"description_width": "90px"},
layout=widgets.Layout(width="390px")
)
amplitud_widget = widgets.FloatSlider(
value=0.40, min=0.0, max=2.0, step=0.05, description="Perturbación:",
continuous_update=False, readout_format=".2f",
style={"description_width": "90px"}, layout=widgets.Layout(width="390px")
)
boton_correr = widgets.Button(
description="🏁 Iniciar carrera", button_style="success",
layout=widgets.Layout(width="190px", height="42px")
)
boton_nuevo = widgets.Button(
description="🎲 Nuevo reto", button_style="info",
layout=widgets.Layout(width="160px", height="42px")
)
boton_reiniciar = widgets.Button(
description="↺ Reiniciar", button_style="warning",
layout=widgets.Layout(width="150px", height="42px")
)
boton_exportar = widgets.Button(
description="⬇ Gráfica HTML", button_style="",
disabled=True, layout=widgets.Layout(width="170px", height="42px")
)
salida = widgets.Output(layout=widgets.Layout(
border="1px solid #CBD5E1", padding="12px", width="100%"
))
ULTIMA_FIGURA = None
ULTIMOS_RESULTADOS = None
def valores_actuales():
return {
"a": a_widget.value,
"b": b_widget.value,
"x0_newton": x0_newton_widget.value,
"x0_secante": x0_secante_widget.value,
"x1_secante": x1_secante_widget.value,
"tol": tol_widget.value,
"max_iter": max_iter_widget.value,
}
def aplicar_escenario(nombre):
datos = ESCENARIOS[nombre]
a_widget.value = datos["a"]
b_widget.value = datos["b"]
x0_newton_widget.value = datos["x0_newton"]
x0_secante_widget.value = datos["x0_secante"]
x1_secante_widget.value = datos["x1_secante"]
descripcion_escenario.value = (
"<div style='padding:9px 12px;background:#EFF6FF;border-left:5px solid #2563EB;"
"border-radius:8px'><b>Qué cambia:</b> " + datos["descripcion"] + "</div>"
)
def al_cambiar_escenario(change):
if change.get("name") == "value":
aplicar_escenario(change["new"])
def mostrar_estado_metodos(resultados):
tarjetas = []
for nombre in NOMBRES_METODOS:
r = resultados[nombre]
color = "#15803D" if r["estado"] == "Convergió" else "#B91C1C"
tarjetas.append(
f"<div style='flex:1;min-width:170px;padding:11px;border:1px solid #E2E8F0;"
f"border-top:5px solid {COLORES[nombre]};border-radius:10px;background:white'>"
f"<b>{nombre}</b><br><span style='color:{color}'>{r['estado']}</span><br>"
f"<small>{r['mensaje']}</small></div>"
)
display(HTML("<div style='display:flex;gap:10px;flex-wrap:wrap'>" + "".join(tarjetas) + "</div>"))
def al_correr(_):
global ULTIMA_FIGURA, ULTIMOS_RESULTADOS
with salida:
clear_output(wait=True)
if prediccion.value is None:
display(HTML(
"<div style='padding:14px;background:#FFF7ED;border-left:6px solid #F97316;"
"border-radius:9px'><b>Primero comprométase con una predicción.</b> "
"Elija el método que cree que ganará y vuelva a pulsar el botón.</div>"
))
return
try:
parametros = valores_actuales()
resultados = ejecutar_todos(**parametros)
robustez = evaluar_robustez(
parametros, amplitud=amplitud_widget.value, cantidad=9
)
tabla = construir_resumen(resultados, robustez)
ganadores = determinar_ganadores(resultados, robustez, criterio.value)
except Exception as exc:
display(HTML(
"<div style='padding:14px;background:#FEF2F2;border-left:6px solid #DC2626;"
f"border-radius:9px'><b>No se pudo ejecutar:</b> {exc}</div>"
))
return
if not ganadores:
titulo_ganador = "No hay ganador: ningún método convergió."
acierto = False
elif len(ganadores) == 1:
titulo_ganador = f"Ganador: {ganadores[0]}"
acierto = prediccion.value == ganadores[0]
else:
titulo_ganador = "Empate: " + ", ".join(ganadores)
acierto = prediccion.value in ganadores
color_resultado = "#15803D" if acierto else "#B45309"
mensaje_pred = (
"¡La predicción coincide con el resultado!"
if acierto else
"La predicción no coincide; revise qué mide realmente el criterio."
)
display(HTML(
"<div style='padding:16px;background:linear-gradient(90deg,#EEF2FF,#F8FAFC);"
"border-radius:12px;border:1px solid #C7D2FE'>"
f"<div style='font-size:24px;font-weight:700'>🏆 {titulo_ganador}</div>"
f"<div style='color:{color_resultado};font-weight:600'>{mensaje_pred}</div>"
f"<div style='margin-top:6px'>{explicacion_criterio(criterio.value)}</div></div>"
))
mostrar_estado_metodos(resultados)
display(HTML("<h3>📊 Tabla resumen</h3>"))
display(
tabla.style
.format({
"Aproximación": "{:.12g}",
"|f(x)|": "{:.3e}",
"|x - x*|": "{:.3e}",
"Robustez empírica": "{:.0f}%",
}, na_rep="—")
.set_properties(subset=["Método"], **{"font-weight": "bold"})
.background_gradient(subset=["Iteraciones"], cmap="Blues_r")
)
display(HTML("<h3>🎬 Carrera: use Reproducir o mueva el deslizador</h3>"))
figura = crear_figura_carrera(resultados, metrica_grafica.value)
figura.show(config={"displaylogo": False, "responsive": True})
display(HTML("<h3>🔎 Vista geométrica: active y desactive métodos en la leyenda</h3>"))
crear_figura_geometrica(resultados).show(
config={"displaylogo": False, "responsive": True}
)
ULTIMA_FIGURA = figura
ULTIMOS_RESULTADOS = resultados
boton_exportar.disabled = False
def al_nuevo_reto(_):
opciones = [x for x in ESCENARIOS if x != selector_escenario.value]
selector_escenario.value = random.choice(opciones)
prediccion.value = None
with salida:
clear_output()
display(HTML(
"<div style='padding:14px;background:#EFF6FF;border-radius:9px'>"
"Se cargó un nuevo reto. <b>Analice los datos y elija su predicción</b> antes de correr."
"</div>"
))
def al_reiniciar(_):
global ULTIMA_FIGURA, ULTIMOS_RESULTADOS
selector_escenario.value = "Caso base recomendado"
criterio.value = "iteraciones"
metrica_grafica.value = "residuo"
tol_widget.value = 1e-8
max_iter_widget.value = 50
amplitud_widget.value = 0.40
prediccion.value = None
ULTIMA_FIGURA = None
ULTIMOS_RESULTADOS = None
boton_exportar.disabled = True
with salida:
clear_output()
display(HTML(
"<div style='padding:14px;background:#F0FDF4;border-radius:9px'>"
"✅ El panel volvió al caso base. Formule una nueva predicción.</div>"
))
def al_exportar(_):
if ULTIMA_FIGURA is None:
return
nombre = "carrera_algoritmos_interactiva.html"
ULTIMA_FIGURA.write_html(nombre, include_plotlyjs=True, full_html=True)
try:
from google.colab import files
files.download(nombre)
except ImportError:
with salida:
print(f"Gráfica guardada como {nombre}")
selector_escenario.observe(al_cambiar_escenario, names="value")
boton_correr.on_click(al_correr)
boton_nuevo.on_click(al_nuevo_reto)
boton_reiniciar.on_click(al_reiniciar)
boton_exportar.on_click(al_exportar)
aplicar_escenario(selector_escenario.value)
panel_decision = widgets.VBox([
widgets.HTML("<h3 style='margin-bottom:4px'>1. Prediga y defina qué significa ganar</h3>"),
selector_escenario,
descripcion_escenario,
widgets.HBox([prediccion, criterio]),
metrica_grafica,
])
panel_parametros = widgets.VBox([
widgets.HTML("<h3 style='margin-bottom:4px'>2. Modifique los datos</h3>"),
widgets.HTML("<b>Métodos acotados</b>"),
widgets.HBox([a_widget, b_widget]),
widgets.HTML("<b>Métodos abiertos</b>"),
widgets.HBox([x0_newton_widget, x0_secante_widget, x1_secante_widget]),
widgets.HBox([tol_widget, max_iter_widget]),
amplitud_widget,
])
acordeon = widgets.Accordion(children=[panel_parametros], selected_index=None)
acordeon.set_title(0, "⚙️ Parámetros numéricos (pulse para desplegar)")
display(widgets.VBox([
widgets.HTML(
"<div style='padding:14px;border-radius:12px;background:#0F172A;color:white'>"
"<span style='font-size:22px;font-weight:700'>🏁 Panel de control</span><br>"
"Prediga, ejecute, observe, cambie el criterio y vuelva a comparar.</div>"
),
panel_decision,
acordeon,
widgets.HBox([boton_correr, boton_nuevo, boton_reiniciar, boton_exportar]),
salida,
]))
1. Prediga y defina qué significa ganar
⚙️ Parámetros numéricos (pulse para desplegar)
2. Modifique los datos
Métodos acotados9.1. Panel 2: carrera con un caso de ciclado de Newton¶
Este segundo panel conserva la misma dinámica de la carrera: primero se formula una predicción, luego se elige qué significa “ganar” y finalmente se comparan Bisección, Falsa Posición, Newton y Secante.
La única modificación matemática es la función:
$$ f_2(x)=x^3-2x+2, \qquad f_2'(x)=3x^2-2. $$
En el escenario base, Bisección, Falsa Posición y Secante reciben datos adecuados para aproximar la raíz real $x^*\approx-1.769292354$. Newton comienza en $x_0=0$ para revelar el ciclo
$$ 0\longrightarrow1\longrightarrow0\longrightarrow1\longrightarrow\cdots. $$
# ============================================================
# MOTOR Y GRÁFICAS INDEPENDIENTES DEL PANEL 2
# f₂(x) = x³ - 2x + 2
# ============================================================
RAIZ_REFERENCIA_P2 = -1.7692923542386314
def f_p2(x):
return x**3 - 2*x + 2
def df_p2(x):
return 3*x**2 - 2
def corregir_error_referencia_p2(resultado):
"""Ajusta la métrica de precisión a la raíz propia del Panel 2."""
for fila in resultado["historial"]:
fila["error_verdadero"] = abs(fila["x"] - RAIZ_REFERENCIA_P2)
aproximacion = resultado["aproximacion"]
resultado["residuo"] = (
abs(float(f_p2(aproximacion)))
if aproximacion is not None and np.isfinite(aproximacion)
else np.inf
)
resultado["error_verdadero"] = (
abs(aproximacion - RAIZ_REFERENCIA_P2)
if aproximacion is not None and np.isfinite(aproximacion)
else np.nan
)
return resultado
def newton_p2(f, df, x0, tol=1e-8, max_iter=100, repeticiones_visibles=3):
"""Newton con detección de ciclo de período 2 y repeticiones visibles."""
historial = []
evaluaciones_f = 0
evaluaciones_df = 0
x = float(x0)
puntos = [x]
ciclo_detectado_en = None
if not all(np.isfinite([x0, tol])) or tol <= 0 or max_iter < 1:
return crear_resultado(
"Newton", "Datos inválidos", None, 0, 0, historial,
"Se requieren datos finitos, tolerancia positiva y máximo de iteraciones positivo."
)
for n in range(1, max_iter + 1):
fx = f(x)
dfx = df(x)
evaluaciones_f += 1
evaluaciones_df += 1
if not np.isfinite(fx) or not np.isfinite(dfx):
return crear_resultado(
"Newton", "Dato no finito", x, n - 1, evaluaciones_f,
historial, "La función o su derivada produjo un valor no finito.",
evaluaciones_df
)
if abs(dfx) < 1e-12:
return crear_resultado(
"Newton", "Derivada problemática", x, n - 1, evaluaciones_f,
historial, "La derivada es demasiado cercana a cero.", evaluaciones_df
)
x_nuevo = x - fx / dfx
fx_nuevo = f(x_nuevo)
evaluaciones_f += 1
if not np.isfinite(x_nuevo) or not np.isfinite(fx_nuevo) or abs(x_nuevo) > 1e12:
return crear_resultado(
"Newton", "Divergencia evidente", x_nuevo, n,
evaluaciones_f, historial,
"La iteración produjo un valor no finito o excesivamente grande.",
evaluaciones_df
)
historial.append({
"n": n,
"x_anterior": x,
"x": x_nuevo,
"f(x)": fx_nuevo,
"f'(x_anterior)": dfx,
"residuo": abs(fx_nuevo),
"error": abs(x_nuevo - x),
"error_verdadero": abs(x_nuevo - RAIZ_REFERENCIA_P2),
})
puntos.append(float(x_nuevo))
if abs(fx_nuevo) < tol:
return crear_resultado(
"Newton", "Convergió", x_nuevo, n, evaluaciones_f,
historial, "Se alcanzó la tolerancia.", evaluaciones_df
)
if (ciclo_detectado_en is None and len(puntos) >= 3
and np.isclose(puntos[-1], puntos[-3], rtol=0, atol=1e-12)
and not np.isclose(puntos[-1], puntos[-2], rtol=0, atol=1e-12)):
ciclo_detectado_en = n
# Tras detectar el ciclo, mostramos tres pasos adicionales y detenemos.
if ciclo_detectado_en is not None and n >= ciclo_detectado_en + repeticiones_visibles:
return crear_resultado(
"Newton", "Ciclo detectado", x_nuevo, n, evaluaciones_f,
historial,
"Oscila en un ciclo de período 2: 0 → 1 → 0 → 1 → ···",
evaluaciones_df
)
x = float(x_nuevo)
return crear_resultado(
"Newton", "Máximo de iteraciones", x, max_iter, evaluaciones_f,
historial, "No se alcanzó la tolerancia.", evaluaciones_df
)
def ejecutar_todos_p2(a, b, x0_newton, x0_secante, x1_secante, tol, max_iter):
"""Ejecuta los cuatro métodos sin utilizar el estado del Panel 1."""
if tol <= 0:
raise ValueError("La tolerancia debe ser positiva.")
if max_iter < 1:
raise ValueError("El máximo de iteraciones debe ser positivo.")
resultados = {
"Bisección": biseccion(f_p2, a, b, tol, max_iter),
"Falsa posición": falsa_posicion(f_p2, a, b, tol, max_iter),
"Newton": newton_p2(f_p2, df_p2, x0_newton, tol, max_iter),
"Secante": secante(f_p2, x0_secante, x1_secante, tol, max_iter),
}
return {nombre: corregir_error_referencia_p2(r)
for nombre, r in resultados.items()}
def evaluar_robustez_p2(parametros, amplitud=0.40, cantidad=9):
desplazamientos = np.linspace(-amplitud, amplitud, cantidad)
estados = {nombre: [] for nombre in NOMBRES_METODOS}
for delta in desplazamientos:
pruebas = ejecutar_todos_p2(
parametros["a"] + delta,
parametros["b"] + delta,
parametros["x0_newton"] + delta,
parametros["x0_secante"] + delta,
parametros["x1_secante"] + delta,
parametros["tol"], parametros["max_iter"],
)
for nombre, resultado in pruebas.items():
estados[nombre].append(resultado["estado"])
return {
nombre: {
"robustez": 100 * sum(e == "Convergió" for e in estados[nombre]) / cantidad,
"exitos": sum(e == "Convergió" for e in estados[nombre]),
"pruebas": cantidad,
"estados": estados[nombre],
}
for nombre in NOMBRES_METODOS
}
def crear_figura_carrera_p2(resultados, metrica="residuo"):
etiqueta_y = "|f₂(xₙ)|" if metrica == "residuo" else "|xₙ - x*|"
series = {n: serie_historial(r, metrica) for n, r in resultados.items()}
max_pasos = max([len(x) for x, _ in series.values()] + [1])
def datos_hasta(paso):
datos = []
for nombre in NOMBRES_METODOS:
xs, ys = series[nombre]
limite = min(paso, len(xs))
datos.append(go.Scatter(
x=xs[:limite], y=ys[:limite], mode="lines+markers", name=nombre,
line=dict(color=COLORES[nombre], width=4), marker=dict(size=8),
hovertemplate=(f"<b>{nombre}</b><br>Iteración %{{x}}<br>"
+ etiqueta_y + " = %{y:.3e}<extra></extra>"),
))
return datos
frames = [go.Frame(data=datos_hasta(k), name=str(k))
for k in range(1, max_pasos + 1)]
fig = go.Figure(data=datos_hasta(1), frames=frames)
pasos = [{
"method": "animate", "label": str(k),
"args": [[str(k)], {"mode": "immediate",
"frame": {"duration": 350, "redraw": True},
"transition": {"duration": 150}}],
} for k in range(1, max_pasos + 1)]
fig.update_layout(
title="Carrera animada del error por iteración — Panel 2",
template="plotly_white", height=520,
xaxis=dict(title="Iteración", dtick=1, rangemode="tozero"),
yaxis=dict(title=etiqueta_y, type="log"), hovermode="x unified",
legend=dict(orientation="h", y=1.12, x=0),
margin=dict(l=60, r=30, t=100, b=80),
updatemenus=[{"type": "buttons", "direction": "left", "x": 0, "y": -0.18,
"buttons": [
{"label": "▶ Reproducir", "method": "animate",
"args": [None, {"frame": {"duration": 500, "redraw": True},
"fromcurrent": True,
"transition": {"duration": 180}}]},
{"label": "⏸ Pausar", "method": "animate",
"args": [[None], {"mode": "immediate",
"frame": {"duration": 0, "redraw": False},
"transition": {"duration": 0}}]},
]}],
sliders=[{"active": 0, "currentvalue": {"prefix": "Iteración mostrada: "},
"pad": {"t": 55}, "steps": pasos}],
)
return fig
def crear_figura_geometrica_p2(resultados):
aproximaciones = [fila["x"] for r in resultados.values()
for fila in r["historial"] if np.isfinite(fila["x"])]
minimo = max(-4, min(aproximaciones + [-2.1]) - 0.3)
maximo = min(3, max(aproximaciones + [1.2]) + 0.3)
xx = np.linspace(minimo, maximo, 700)
fig = go.Figure()
fig.add_trace(go.Scatter(
x=xx, y=f_p2(xx), mode="lines", name="f₂(x)=x³−2x+2",
line=dict(color="#111827", width=3)
))
fig.add_hline(y=0, line_color="#64748B", line_width=1)
fig.add_vline(x=RAIZ_REFERENCIA_P2, line_dash="dash", line_color="#7C3AED",
annotation_text="x*", annotation_position="top")
for nombre in NOMBRES_METODOS:
hist = resultados[nombre]["historial"]
xs = [fila["x"] for fila in hist]
ys = [fila["f(x)"] for fila in hist]
ns = [fila["n"] for fila in hist]
fig.add_trace(go.Scatter(
x=xs, y=ys, mode="markers+lines", name=nombre,
marker=dict(size=8, color=COLORES[nombre]),
line=dict(color=COLORES[nombre], width=2, dash="dot"),
customdata=ns,
hovertemplate=(f"<b>{nombre}</b><br>n=%{{customdata}}<br>"
"x=%{x:.10f}<br>f₂(x)=%{y:.3e}<extra></extra>"),
))
# Las tangentes hacen visible el regreso 0 → 1 → 0 del caso de Newton.
for j, fila in enumerate(resultados["Newton"]["historial"]):
xa, xb = fila["x_anterior"], fila["x"]
ya, m = f_p2(xa), fila["f'(x_anterior)"]
xt = np.linspace(min(xa, xb) - 0.08, max(xa, xb) + 0.08, 40)
fig.add_trace(go.Scatter(
x=xt, y=ya + m * (xt - xa), mode="lines",
name="Tangente de Newton" if j == 0 else None,
showlegend=(j == 0),
line=dict(color="#DC2626", width=2), opacity=max(0.3, 0.9 - 0.1*j),
hoverinfo="skip",
))
fig.update_layout(
title="Aproximaciones y tangentes sobre la gráfica de f₂",
template="plotly_white", height=500, xaxis_title="x", yaxis_title="f₂(x)",
legend=dict(orientation="h", y=1.16, x=0),
margin=dict(l=60, r=30, t=105, b=55),
)
return fig
# ============================================================
# INTERFAZ INTERACTIVA DE LA CARRERA
# ============================================================
ESCENARIOS_P2 = {
"Caso base: Newton entra en ciclo": {
"descripcion": "Newton inicia en x₀=0 y alterna entre 0 y 1; los otros métodos reciben datos válidos.",
"a": -2.0, "b": -1.0, "x0_newton": 0.0,
"x0_secante": -2.0, "x1_secante": -1.0,
},
"Intervalo más amplio": {
"descripcion": "Todos los métodos comienzan con datos distintos, pero adecuados para buscar la raíz real.",
"a": -3.0, "b": -1.0, "x0_newton": -2.0,
"x0_secante": -3.0, "x1_secante": -1.0,
},
"Newton cerca de derivada cero": {
"descripcion": "Newton inicia donde f₂'(x)≈0; los demás conservan datos apropiados.",
"a": -2.0, "b": -1.0, "x0_newton": -math.sqrt(2/3),
"x0_secante": -2.0, "x1_secante": -1.0,
},
"Secante con datos repetidos": {
"descripcion": "Secante recibe dos valores iguales y reporta una división problemática.",
"a": -2.0, "b": -1.0, "x0_newton": -2.0,
"x0_secante": -1.5, "x1_secante": -1.5,
},
}
selector_escenario_p2 = widgets.Dropdown(
options=list(ESCENARIOS_P2), value="Caso base: Newton entra en ciclo",
description="Escenario:", style={"description_width": "95px"},
layout=widgets.Layout(width="480px")
)
descripcion_escenario_p2 = widgets.HTML()
prediccion_p2 = widgets.Dropdown(
options=[("— Elige antes de correr —", None)] + [(n, n) for n in NOMBRES_METODOS],
value=None, description="Predicción:",
style={"description_width": "95px"}, layout=widgets.Layout(width="320px")
)
criterio_p2 = widgets.Dropdown(
options=[
("Menos iteraciones", "iteraciones"),
("Menos evaluaciones de f", "evaluaciones_f"),
("Menos evaluaciones totales", "evaluaciones_totales"),
("Mayor precisión", "precision"),
("Mayor robustez empírica", "robustez"),
],
value="iteraciones", description="Ganar =",
style={"description_width": "95px"}, layout=widgets.Layout(width="350px")
)
metrica_grafica_p2 = widgets.ToggleButtons(
options=[("Residuo |f(xₙ)|", "residuo"), ("Error |xₙ-x*|", "error_verdadero")],
value="residuo", description="Gráfica:",
style={"description_width": "70px"}
)
a_widget_p2 = widgets.FloatText(value=-2.0, description="a:", layout=widgets.Layout(width="190px"))
b_widget_p2 = widgets.FloatText(value=-1.0, description="b:", layout=widgets.Layout(width="190px"))
x0_newton_widget_p2 = widgets.FloatText(value=0.0, description="Newton x₀:",
style={"description_width": "85px"},
layout=widgets.Layout(width="220px"))
x0_secante_widget_p2 = widgets.FloatText(value=-2.0, description="Secante x₀:",
style={"description_width": "85px"},
layout=widgets.Layout(width="220px"))
x1_secante_widget_p2 = widgets.FloatText(value=-1.0, description="Secante x₁:",
style={"description_width": "85px"},
layout=widgets.Layout(width="220px"))
tol_widget_p2 = widgets.SelectionSlider(
options=[("10⁻⁴", 1e-4), ("10⁻⁶", 1e-6), ("10⁻⁸", 1e-8), ("10⁻¹⁰", 1e-10)],
value=1e-8, description="Tolerancia:", continuous_update=False,
style={"description_width": "90px"}, layout=widgets.Layout(width="390px")
)
max_iter_widget_p2 = widgets.IntSlider(
value=50, min=1, max=100, step=1, description="Máx. iter.:",
continuous_update=False, style={"description_width": "90px"},
layout=widgets.Layout(width="390px")
)
amplitud_widget_p2 = widgets.FloatSlider(
value=0.40, min=0.0, max=2.0, step=0.05, description="Perturbación:",
continuous_update=False, readout_format=".2f",
style={"description_width": "90px"}, layout=widgets.Layout(width="390px")
)
boton_correr_p2 = widgets.Button(
description="🏁 Iniciar carrera", button_style="success",
layout=widgets.Layout(width="190px", height="42px")
)
boton_nuevo_p2 = widgets.Button(
description="🎲 Nuevo reto", button_style="info",
layout=widgets.Layout(width="160px", height="42px")
)
boton_reiniciar_p2 = widgets.Button(
description="↺ Reiniciar", button_style="warning",
layout=widgets.Layout(width="150px", height="42px")
)
boton_exportar_p2 = widgets.Button(
description="⬇ Gráfica HTML", button_style="",
disabled=True, layout=widgets.Layout(width="170px", height="42px")
)
salida_p2 = widgets.Output(layout=widgets.Layout(
border="1px solid #CBD5E1", padding="12px", width="100%"
))
ULTIMA_FIGURA_P2 = None
ULTIMOS_RESULTADOS_P2 = None
def valores_actuales_p2():
return {
"a": a_widget_p2.value,
"b": b_widget_p2.value,
"x0_newton": x0_newton_widget_p2.value,
"x0_secante": x0_secante_widget_p2.value,
"x1_secante": x1_secante_widget_p2.value,
"tol": tol_widget_p2.value,
"max_iter": max_iter_widget_p2.value,
}
def aplicar_escenario_p2(nombre):
datos = ESCENARIOS_P2[nombre]
a_widget_p2.value = datos["a"]
b_widget_p2.value = datos["b"]
x0_newton_widget_p2.value = datos["x0_newton"]
x0_secante_widget_p2.value = datos["x0_secante"]
x1_secante_widget_p2.value = datos["x1_secante"]
descripcion_escenario_p2.value = (
"<div style='padding:9px 12px;background:#EFF6FF;border-left:5px solid #2563EB;"
"border-radius:8px'><b>Qué cambia:</b> " + datos["descripcion"] + "</div>"
)
def al_cambiar_escenario_p2(change):
if change.get("name") == "value":
aplicar_escenario_p2(change["new"])
def mostrar_estado_metodos_p2(resultados):
tarjetas = []
for nombre in NOMBRES_METODOS:
r = resultados[nombre]
color = "#15803D" if r["estado"] == "Convergió" else "#B91C1C"
tarjetas.append(
f"<div style='flex:1;min-width:170px;padding:11px;border:1px solid #E2E8F0;"
f"border-top:5px solid {COLORES[nombre]};border-radius:10px;background:white'>"
f"<b>{nombre}</b><br><span style='color:{color}'>{r['estado']}</span><br>"
f"<small>{r['mensaje']}</small></div>"
)
display(HTML("<div style='display:flex;gap:10px;flex-wrap:wrap'>" + "".join(tarjetas) + "</div>"))
def al_correr_p2(_):
global ULTIMA_FIGURA_P2, ULTIMOS_RESULTADOS_P2
with salida_p2:
clear_output(wait=True)
if prediccion_p2.value is None:
display(HTML(
"<div style='padding:14px;background:#FFF7ED;border-left:6px solid #F97316;"
"border-radius:9px'><b>Primero comprométase con una predicción.</b> "
"Elija el método que cree que ganará y vuelva a pulsar el botón.</div>"
))
return
try:
parametros = valores_actuales_p2()
resultados = ejecutar_todos_p2(**parametros)
robustez = evaluar_robustez_p2(
parametros, amplitud=amplitud_widget_p2.value, cantidad=9
)
tabla = construir_resumen(resultados, robustez)
ganadores = determinar_ganadores(resultados, robustez, criterio_p2.value)
except Exception as exc:
display(HTML(
"<div style='padding:14px;background:#FEF2F2;border-left:6px solid #DC2626;"
f"border-radius:9px'><b>No se pudo ejecutar:</b> {exc}</div>"
))
return
if not ganadores:
titulo_ganador = "No hay ganador: ningún método convergió."
acierto = False
elif len(ganadores) == 1:
titulo_ganador = f"Ganador: {ganadores[0]}"
acierto = prediccion_p2.value == ganadores[0]
else:
titulo_ganador = "Empate: " + ", ".join(ganadores)
acierto = prediccion_p2.value in ganadores
color_resultado = "#15803D" if acierto else "#B45309"
mensaje_pred = (
"¡La predicción coincide con el resultado!"
if acierto else
"La predicción no coincide; revise qué mide realmente el criterio_p2."
)
display(HTML(
"<div style='padding:16px;background:linear-gradient(90deg,#EEF2FF,#F8FAFC);"
"border-radius:12px;border:1px solid #C7D2FE'>"
f"<div style='font-size:24px;font-weight:700'>🏆 {titulo_ganador}</div>"
f"<div style='color:{color_resultado};font-weight:600'>{mensaje_pred}</div>"
f"<div style='margin-top:6px'>{explicacion_criterio(criterio_p2.value)}</div></div>"
))
mostrar_estado_metodos_p2(resultados)
display(HTML("<h3>📊 Tabla resumen</h3>"))
display(
tabla.style
.format({
"Aproximación": "{:.12g}",
"|f(x)|": "{:.3e}",
"|x - x*|": "{:.3e}",
"Robustez empírica": "{:.0f}%",
}, na_rep="—")
.set_properties(subset=["Método"], **{"font-weight": "bold"})
.background_gradient(subset=["Iteraciones"], cmap="Blues_r")
)
display(HTML("<h3>🎬 Carrera: use Reproducir o mueva el deslizador</h3>"))
figura = crear_figura_carrera_p2(resultados, metrica_grafica_p2.value)
figura.show(config={"displaylogo": False, "responsive": True})
display(HTML("<h3>🔎 Vista geométrica: active y desactive métodos en la leyenda</h3>"))
crear_figura_geometrica_p2(resultados).show(
config={"displaylogo": False, "responsive": True}
)
ULTIMA_FIGURA_P2 = figura
ULTIMOS_RESULTADOS_P2 = resultados
boton_exportar_p2.disabled = False
def al_nuevo_reto_p2(_):
opciones = [x for x in ESCENARIOS_P2 if x != selector_escenario_p2.value]
selector_escenario_p2.value = random.choice(opciones)
prediccion_p2.value = None
with salida_p2:
clear_output()
display(HTML(
"<div style='padding:14px;background:#EFF6FF;border-radius:9px'>"
"Se cargó un nuevo reto. <b>Analice los datos y elija su predicción</b> antes de correr."
"</div>"
))
def al_reiniciar_p2(_):
global ULTIMA_FIGURA_P2, ULTIMOS_RESULTADOS_P2
selector_escenario_p2.value = "Caso base: Newton entra en ciclo"
criterio_p2.value = "iteraciones"
metrica_grafica_p2.value = "residuo"
tol_widget_p2.value = 1e-8
max_iter_widget_p2.value = 50
amplitud_widget_p2.value = 0.40
prediccion_p2.value = None
ULTIMA_FIGURA_P2 = None
ULTIMOS_RESULTADOS_P2 = None
boton_exportar_p2.disabled = True
with salida_p2:
clear_output()
display(HTML(
"<div style='padding:14px;background:#F0FDF4;border-radius:9px'>"
"✅ El panel volvió al caso base. Formule una nueva predicción.</div>"
))
def al_exportar_p2(_):
if ULTIMA_FIGURA_P2 is None:
return
nombre = "carrera_algoritmos_panel2_ciclo.html"
ULTIMA_FIGURA_P2.write_html(nombre, include_plotlyjs=True, full_html=True)
try:
from google.colab import files
files.download(nombre)
except ImportError:
with salida_p2:
print(f"Gráfica guardada como {nombre}")
selector_escenario_p2.observe(al_cambiar_escenario_p2, names="value")
boton_correr_p2.on_click(al_correr_p2)
boton_nuevo_p2.on_click(al_nuevo_reto_p2)
boton_reiniciar_p2.on_click(al_reiniciar_p2)
boton_exportar_p2.on_click(al_exportar_p2)
aplicar_escenario_p2(selector_escenario_p2.value)
panel_decision_p2 = widgets.VBox([
widgets.HTML("<h3 style='margin-bottom:4px'>1. Prediga y defina qué significa ganar</h3>"),
selector_escenario_p2,
descripcion_escenario_p2,
widgets.HBox([prediccion_p2, criterio_p2]),
metrica_grafica_p2,
])
panel_parametros_p2 = widgets.VBox([
widgets.HTML("<h3 style='margin-bottom:4px'>2. Modifique los datos</h3>"),
widgets.HTML("<b>Métodos acotados</b>"),
widgets.HBox([a_widget_p2, b_widget_p2]),
widgets.HTML("<b>Métodos abiertos</b>"),
widgets.HBox([x0_newton_widget_p2, x0_secante_widget_p2, x1_secante_widget_p2]),
widgets.HBox([tol_widget_p2, max_iter_widget_p2]),
amplitud_widget_p2,
])
acordeon_p2 = widgets.Accordion(children=[panel_parametros_p2], selected_index=None)
acordeon_p2.set_title(0, "⚙️ Parámetros numéricos (pulse para desplegar)")
display(widgets.VBox([
widgets.HTML(
"<div style='padding:14px;border-radius:12px;background:#0F172A;color:white'>"
"<span style='font-size:22px;font-weight:700'>🏁 Panel de control 2</span><br>"
"Prediga, ejecute, observe, cambie el criterio_p2 y vuelva a comparar.</div>"
),
panel_decision_p2,
acordeon_p2,
widgets.HBox([boton_correr_p2, boton_nuevo_p2, boton_reiniciar_p2, boton_exportar_p2]),
salida_p2,
]))
1. Prediga y defina qué significa ganar
⚙️ Parámetros numéricos (pulse para desplegar)
2. Modifique los datos
Métodos acotados¿Por qué Newton se cicla en el escenario base?¶
Para $x_0=0$ se obtiene
$$ x_1=0-\frac{f_2(0)}{f_2'(0)} =0-\frac{2}{-2}=1. $$
Luego, desde $x_1=1$,
$$ x_2=1-\frac{f_2(1)}{f_2'(1)} =1-\frac{1}{1}=0. $$
La tangente trazada en $x=0$ conduce a $x=1$, mientras que la tangente trazada en $x=1$ devuelve el algoritmo a $x=0$. Por eso el proceso repite indefinidamente los mismos dos valores. El código detecta este ciclo, dibuja tres pasos adicionales para hacerlo visible y se detiene mediante un tope de seguridad.
Los otros métodos no comparten este problema en el caso base: Bisección y Falsa Posición mantienen la raíz encerrada en $[-2,-1]$, y Secante comienza con los dos valores distintos $-2$ y $-1$.
Guía de uso del panel interactivo:¶
10. ¿Qué significa lo que observamos?¶
10.1. Bisección¶
Si $f$ es continua y $f(a)f(b)<0$, bisección conserva una raíz encerrada. Después de $n$ particiones, la longitud del intervalo es
$$ \frac{b_0-a_0}{2^n}, $$
y el error del punto medio queda acotado por la mitad de esa longitud. Su convergencia es lineal: puede necesitar más iteraciones, pero ofrece una garantía clara cuando se cumplen las hipótesis.
10.2. Falsa posición¶
Falsa posición también conserva el cambio de signo, pero utiliza una interpolación lineal. Para $f(x)=\cos(x)-x$ y $[0,1]$, suele necesitar menos iteraciones que bisección. Esto no se generaliza automáticamente: en otras funciones uno de los extremos puede permanecer casi fijo y el método puede estancarse.
10.3. Newton¶
Si la raíz $r$ es simple, $f$ es suficientemente regular, $f'(r)\neq0$ y $x_0$ está en una zona adecuada, Newton presenta convergencia cuadrática local. De manera aproximada,
$$ |e_{n+1}|\approx C|e_n|^2. $$
Por eso puede ganar en iteraciones y precisión. Sin embargo, cada paso utiliza $f$ y $f'$, y el método puede fallar si la derivada es nula o si el valor inicial es desfavorable.
10.4. Secante¶
Secante evita calcular $f'$ y, bajo condiciones locales apropiadas, tiene orden de convergencia aproximado
$$ p=\frac{1+\sqrt5}{2}\approx1.618. $$
Es superlineal, pero no cuadrático. Puede equilibrar rapidez y costo por iteración; aun así, no mantiene necesariamente una raíz encerrada y puede sufrir una división problemática si dos evaluaciones consecutivas son casi iguales.
10.5. Conclusión central¶
No existe un ganador universal:
- menos iteraciones favorece rapidez de actualización, pero ignora el costo de cada paso;
- menos evaluaciones de $f$ no contabiliza por sí solo el costo de $f'$;
- más precisión depende de la regla de parada, el redondeo y la raíz de referencia;
- más robustez depende de las hipótesis del método y de los datos ensayados.
Por tanto, elegir un método depende del problema, de la información disponible y del criterio de desempeño. Que un método gane una carrera numérica constituye evidencia para esa configuración; no demuestra que sea siempre el mejor.
11. Prueba por tu cuenta¶
- Cambie solo el criterio. Use el caso base con tolerancia $10^{-8}$. Primero seleccione “menos iteraciones” y luego “menos evaluaciones de $f$”. ¿Permanece el mismo ganador? Explique por qué.
- Estrese los datos. Seleccione “Newton cerca de derivada cero”. Prediga qué estado reportará Newton antes de ejecutar. ¿Por qué los métodos acotados no presentan ese mismo problema?
- Explore la tolerancia. Compare $10^{-4}$ y $10^{-10}$. ¿Qué métodos aumentan más su número de iteraciones? Relacione el resultado con convergencia lineal, superlineal o cuadrática.
Reto final para el público: después de la primera carrera, cambie el criterio de “ganador” y prediga si el método preferido seguirá siendo el mismo. Justifique la predicción antes de pulsar Iniciar carrera otra vez.
13. Código QR para la modalidad individual
En esta versión HTML, el código QR se genera automáticamente con la dirección actual de esta misma página. Cuando el archivo esté publicado en una URL accesible, al escanear el QR se abrirá directamente este mismo HTML.
Nota: si el archivo se abre localmente con una dirección file://, esa dirección solo existe en el equipo donde se abrió.
Para compartir el QR con otras personas, publique primero el HTML en un sitio web.
# ============================================================
# CÓDIGO QR DE LA VERSIÓN HTML
# ============================================================
# En esta versión web no se fija manualmente una URL.
# El HTML toma en tiempo de ejecución su propia dirección:
#
# ENLACE_HTML = window.location.href
#
# y genera el código QR con esa misma dirección.
# Así, una vez publicado el archivo, escanear el QR abre este mismo HTML.
14. Referencias¶
- Curso EM-4612 Métodos Numéricos. Actividad de la Semana MATEC: Taller interactivo de métodos numéricos con Google Colab. II semestre de 2026.
- Jupyter Widgets. ipywidgets documentation: Using Interact, interactive_output and widget controls. https://ipywidgets.readthedocs.io/
- Google. Google Colaboratory - Frequently Asked Questions. https://research.google.com/colaboratory/faq.html
- Plotly. Displaying figures in Python - Renderers, including Google Colab. https://plotly.com/python/renderers/