32. Tamaño del paso | Modelos Continuos y Sistemas Dinámicos

01 · Punto de partida

Todo dt es una negociación

dt = 2 corre en 5 pasos y miente; dt = 0,01 clava y tarda 1000 pasos. Entre ambos hay un dt* que cumple el error pedido con el menor costo. Elegirlo es el oficio: error tolerado + barrido + verificación.

La regla de oro: el paso debe resolver la escala más rápida (dt ≪ 1/k) y el costo debe entrar en el presupuesto.

¿Qué error tolero en el horizonte (0,1? ¿0,01?)?
¿Qué dt lo cumple con cada método?
¿Cuántas f cuesta cada opción?
¿El dt elegido es estable (Tema 34)?

02 · Definición

¿Qué es elegir el paso?

Un problema de optimización con tres datos:

Tolerancia

Error máximo aceptado en T: 1, 0,1, 0,01. La pide la pregunta, no el programador.

∝

Ley error–dt

Euler ∝ dt, RK2 ∝ dt², RK4 ∝ dt⁴: partir dt divide el error por 2, 4 o 16.

Costo T/dt × etapas

Partir dt duplica el costo: la precisión se compra con evaluaciones de f.

error \approx C\cdotdt^p \cdot costo = (T/dt)\cdotetapas

En log-log, cada método es una recta de pendiente p: Euler 1, RK2 2, RK4 4. La más empinada gana al achicar dt.

Logístico r = 0,5, T = 10: dt para error ≈ 0,1.
Método	dt*	Costo en f
Euler	≈ 0,07 (140 pasos)	140 (caro).
RK2	≈ 1 (10 pasos)	20 (barato).
RK4	≈ 2 (5 pasos)	20 (igual y sobra).
Euler dt = 2	error ≈ 3 (no cumple)	5 (barato e inútil).

03 · Anatomía

Física, tolerancia y presupuesto

El dt se negocia en tres mesas:

Resuelve la física: dt ≪ escala rápida: ≤ (1/k)/10, ≤ período/20. Si no, deforma aunque el error final mienta.
Cumple la tolerancia: Barrer dt y quedarse con el mayor que da error ≤ tol. El borde es el óptimo.
Entra en presupuesto: Costo = pasos × etapas ≤ f disponibles. Con f cara, RK gana siempre.
Mantiene estabilidad: dt bajo el límite del método (Euler: 2/λ). Un dt preciso pero inestable no existe.

dt grande

Barato y mentiroso

5 pasos, error 3: la curva se pasa en la subida. Ahorra cómputo, pierde la pregunta.

dt chico

Caro y fiel

200 pasos, error 0,007: clava la curva. Si el presupuesto lo permite, es la respuesta.

04 · El paso en el curso

Cada laboratorio negoció el suyo

Cada dt usado tenía sus razones:

Física + tol→Barrido→dt*

1
Tanque k = 0,2.
Escala 1/k = 5: dt = 0,5 sobra (10×). Barato y fiel.
2
Resorte k = 2.
Período ≈ 4,4: dt = 0,02 (220×). La oscilación pide fino.
3
SIR.
Escala días: dt = 0,5 alcanza. Lento permite ancho.
4
Duelo (Tema 28).
dt = 1 a propósito grueso: para que se vea el error.
5
RK4 fino.
dt = 1 ya sobra: el orden paga el paso.

05 · Representación en Python

Barrer dt y quedarse con el mayor que cumple

En Python, elegir dt es un bucle de barrido sobre la exacta testigo: el primero que cumple, empezando del grande, es dt*.

Python en tu navegador. Estos bloques se ejecutan localmente con Pyodide, sin instalar nada. Bajá la tolerancia a 0,01 y observá cómo Euler se vuelve carísimo.

import math


def exacta(t, p0=10.0, r=0.5, k=100.0):
    return k / (1 + (k - p0) / p0 * math.exp(-r * t))


def euler(f, x0, t_final, dt):
    x, t = x0, 0.0
    while t < t_final - 1e-9:
        h = min(dt, t_final - t)
        x, t = x + f(x, t) * h, t + h
    return x


f = lambda p, t: 0.5 * p * (1 - p / 100)
ex = exacta(10)
for dt in [2, 1, 0.5, 0.25, 0.1]:
    print(dt, round(abs(ex - euler(f, 10, 10, dt)), 3))

3 → 1,42 → 0,68 → 0,33 → 0,13: partir dt parte el error. Para 0,1 hay que bajar a ≈ 0,07.

dt* automático

El mayor dt que cumple la tolerancia, con su costo:

def dt_estrella(tol=0.1, t_final=10.0):
    for dt in [2, 1, 0.5, 0.25, 0.1, 0.05]:
        if abs(ex - euler(f, 10, t_final, dt)) <= tol:
            return dt, int(t_final / dt)


print(dt_estrella(0.1))

06 · Exploración

Laboratorio: la recta del error en log-log

Barrido de dt en el logístico (r con tu slider, T = 10): Euler teal de pendiente 1, RK2 naranja de pendiente 2, RK4 blanca de pendiente 4. La línea punteada es tu tolerancia: cada método la cruza en su dt*. Movete la tolerancia y observá quién se vuelve carísimo.

EXPERIMENTO 32

Error contra paso

log(error) vs log(dt) · pendientes 1, 2, 4

Tasa r: 0,50 Tolerancia: 0,10 Tu dt: 1,00

dt* Euler0,07

dt* RK21,00

dt* RK42,00

Tu error/costo—

Con tol 0,10: Euler pide dt 0,07 (140 f), RK2 dt 1 (20 f).

El eje x es dt (2 → 0,03) y el y es error en log: cada recta cae con su pendiente. Tu dt marca dónde estás parado con Euler.

Preguntas para explorar

Con tol 0,01, ¿qué dt* pide Euler? ¿Y RK4?
Con r = 1,0, ¿las rectas suben? ¿dt* se achica?
Si tu dt = 2 con tol 0,10, ¿cumplís con Euler? ¿Con RK4?

Ver respuestas sugeridas

Euler dt ≈ 0,007–0,01 (~1000 f); RK4 dt ≈ 1 (40 f). Dos órdenes de costo.
Sí: más curvatura, más error a igual dt. El barrido se repite por modelo.
No con Euler (error ≈ 3); sí con RK4 (error ≈ 0,01). El método decide el paso.

07 · Comprensión

Confusiones frecuentes

«dt chico siempre es seguro»

Seguro de precisión, no de costo ni de redondeo: dt absurdo acumula flotantes y tarda. Hay piso útil.

«dt* es universal»

Vale para ese modelo, ese T y esa tol: cambiar r, T o tol lo mueve. Se recalcula, no se recita.

«La pendiente log-log miente»

Solo si dt es tan grande que sale del régimen asintótico: con dt = 2 Euler ya deforma y la recta se dobla.

«Tolerancia es gusto»

La pide la pregunta (dosis, dosis, riesgo): 0,1 en logística no es 0,1 en SIR con vidas en juego.

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: leer la pendiente

Con errores Euler 2,84 (dt = 2) y 1,42 (dt = 1), ¿qué pendiente log-log confirma? ¿Y orden?

import math


pend = math.log(2.84 / 1.42) / math.log(2 / 1)
print(round(pend, 2), "→ orden", round(pend))

Ver solución

Pendiente ≈ 1,0 → orden 1: partir dt parte el error. Firma de Euler.

Ejercicio 2: costo para tol 0,1

Si Euler necesita dt = 0,07 en T = 10, ¿cuántas f cuesta? ¿Y RK2 con dt = 1?

print("euler:", round(10 / 0.07), "f · rk2:", 10 * 2, "f")

Ver solución

≈ 143 f frente a 20 f: 7 veces más caro por el mismo error. El orden paga.

Ejercicio 3: dt* desde la física

Con k = 0,5 y regla dt ≤ (1/k)/10, ¿qué dt sale? ¿Cumple error 0,1 en el tanque con Euler?

Ver una posible respuesta

k = 0.5
print("dt =", (1 / k) / 10)

dt = 0,2: resuelve la física (1/k = 2) con 10 puntos. En el tanque lineal el error es chico; la verificación con barrido lo confirma.

09 · Síntesis

Ideas para recordar

dt* = mayor paso con error ≤ tol y estable: se barrea, no se adivina.
En log-log el error es recta de pendiente p: 1, 2, 4 según método.
Costo = (T/dt) × etapas: la precisión se compra en f.
En Python: barrido sobre la exacta + dt_estrella(tol) con costo.
dt sale de física (1/k, período), tolerancia (pregunta) y estabilidad.

En el próximo tema mediremos el error numérico: de dónde viene y cómo se acumula.