Discretización del tiempo

01 · Punto de partida

El continuo no cabe en memoria

El intervalo [0, 12] tiene infinitos instantes y la memoria guarda finitos. La salida es la malla: [0, dt, 2·dt, …, T]. Entre nodos, el integrador supone; en los nodos, calcula. Todo el bloque numérico se para sobre este andamio.

Discretizar bien es decidir dt, contar nodos y no pasarse del horizonte: tres líneas que evitan la mitad de los bugs numéricos.

• ¿Qué dt resuelve la curva más rápida del modelo?
• ¿Cuántos nodos hay y cuánto cuesta?
• ¿dt divide a T o se recorta el último paso?
• ¿Muestreo y paso son el mismo número?

02 · Definición

¿Qué es discretizar el tiempo?

Del continuo a la lista:

Sin recorte, dt = 5 en T = 12 calcula en 15: tres minutos de ficción más allá de la pregunta.

03 · Anatomía

Malla, muestreo y horizonte

Tres decisiones con tres nombres:

Malla (dt)

Dónde calcula el integrador: fina para precisión, gruesa para explorar.

Muestreo (cada)

Dónde guarda o grafica: puede ser cada k pasos. Integrar fino y guardar ralo.

Horizonte (T)

Hasta dónde: el fin de la pregunta. Pasarse inventa tiempo.

Costo (≈ T/dt)

Nodos × etapas: partir dt a la mitad duplica el costo en Euler.

04 · Discretizar en el curso

El andamio de cada laboratorio

Cada canvas del curso es una malla con su dt:

1. 1
   Tanque (Temas 4–5).

   dt = 0,05 invisible: la curva parece continua.

2. 2
   Euler vs exacta (Tema 8).

   dt visible a propósito: la escalera enseña.

3. 3
   Resorte (Tema 9).

   dt = 0,02: la oscilación pide malla fina.

4. 4
   SIR (Tema 20).

   dt = 0,5 días: la epidemia es lenta y permite paso ancho.

5. 5
   Duelo (Tema 28).

   dt barrido: el error se mide contra la malla.

05 · Representación en Python

Malla con recorte en cinco líneas

En Python, la malla es un while con min(): avanza dt y recorta el último salto a T.

def malla(t_final=12.0, dt=2.0):
    tiempos, t = [0.0], 0.0
    while t < t_final - 1e-9:
        t = min(t + dt, t_final)
        tiempos.append(round(t, 3))
    return tiempos


print(malla(12, 4))
print(malla(12, 5))

[0, 4, 8, 12] y [0, 5, 10, 12]: el segundo recorta el último a 2.

Integrar sobre la malla

El integrador recorre la malla, no el continuo:

def euler_malla(f, x0, t_final, dt):
    x, t = x0, 0.0
    historia = [(t, x)]
    while t < t_final - 1e-9:
        h = min(dt, t_final - t)
        x = x + f(x, t) * h
        t += h
        historia.append((round(t, 3), round(x, 3)))
    return historia


f = lambda x, t: 3 - 0.2 * x
print(euler_malla(f, 2, 6, dt=2)[-1])

06 · Exploración

Laboratorio: la malla sobre la curva

Recta exacta N(t) = 10 + t (dorada) con tus nodos teal unidos por escalera de Euler. Movete dt y observá dos cosas: cuántos nodos hay y cómo la escalera miente entre ellos aunque clave los nodos. Con dt = 5 mirá el último paso recortado a T.

Los nodos clavan la recta (tasa constante); la escalera entre ellos es puro artefacto del dibujo por pasos.

Preguntas para explorar

1. Con dt = 5 y T = 12, ¿qué nodos hay? ¿Cuánto mide el último?
2. Con dt = 0,5, ¿cuántos nodos hay? ¿La escalera se nota?
3. Si T = 13 y dt = 5, ¿el recorte es mayor o menor que dt?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: contar nodos

Sin ejecutar: ¿cuántos nodos hay en [0, 12] con dt = 3? ¿Y el último paso con dt = 5? Comprobalo.

def malla(t_final=12.0, dt=3.0):
    tiempos, t = [0.0], 0.0
    while t < t_final - 1e-9:
        t = min(t + dt, t_final)
        tiempos.append(round(t, 3))
    return tiempos


print(len(malla(12, 3)), malla(12, 3))
print(malla(12, 5))

Ejercicio 2: costo de la malla

Con T = 30, ¿cuántos pasos hay con dt = 2, 0,5 y 0,1? ¿Cuánto cuesta RK4 en cada caso?

for dt in [2, 0.5, 0.1]:
    pasos = len(malla(30, dt)) - 1
    print(dt, pasos, "pasos · RK4:", pasos * 4, "f")

Ejercicio 3: malla que respeta la física

Elegí dt para un tanque con k = 0,5 (tiempo 1/k = 2) con regla dt ≤ (1/k)/10. ¿Qué dt y cuántos nodos en T = 20?

def elegir_dt(k, t_final, por_escala=10):
    dt = (1 / k) / por_escala
    return dt, len(malla(t_final, dt))


print(elegir_dt(0.5, 20))

09 · Síntesis

Ideas para recordar

En el próximo tema usaremos la malla más simple: el método de Euler.