Tiempo continuo

01 · Punto de partida

El reloj que nunca se detiene

En el Tema 1 vimos que un sistema continuo fluye en todo instante. Ahora miramos el reloj mismo: entre el segundo 2 y el segundo 3 también existen t = 2,1, t = 2,37 y t = 2,718. El tiempo no avanza por turnos ni espera a que lo midamos.

Cuando programamos, en cambio, estamos obligados a avanzar por pasos: calculamos en t = 0, luego en t = dt, luego en t = 2·dt. La pregunta central del tema es: ¿cómo representar un tiempo sin saltos dentro de un programa que avanza por saltos?

• ¿Qué instantes existen entre dos mediciones?
• ¿Qué perdemos al avanzar con pasos grandes?
• ¿Qué significa que dt tienda a cero?
• ¿Hasta cuándo simulamos: cuál es el horizonte?

02 · Definición

¿Qué es el tiempo continuo?

El tiempo continuo tiene tres ingredientes inseparables:

La misma historia puede contarse con relojes distintos: el sistema vive en tiempo continuo, la medición lo muestrea y la simulación lo integra por pasos. Los tres relojes deben distinguirse.

03 · Anatomía

Instante, paso, horizonte y muestreo

Para no mezclar los relojes conviene nombrar cada pieza con precisión:

Instante t

Punto del reloj continuo: puede ser 3, 3,5 o 3,14159. Siempre hay más entre dos dados.

Paso dt

Salto de la aproximación numérica: 1, 0,5, 0,1. No es del sistema, es de nuestro programa.

Horizonte T

Fin de la simulación: hasta dónde integramos la trayectoria.

Muestreo

Cada cuánto observamos o guardamos: puede ser distinto de dt.

04 · Tiempo en los modelos

Dónde aparece el reloj

El tiempo continuo reordena las distinciones clásicas de modelos. Tres preguntas bastan para ubicarse:

1. 1
   Estático o dinámico.

   Una foto (costo de hoy) no necesita reloj; una película (nivel durante 12 minutos) sí. Este curso es dinámico.

2. 2
   Discreto, continuo o híbrido.

   Por eventos (llegan clientes), por flujos (entra agua) o mezclando ambos (tanque con descargas puntuales).

3. 3
   Horizonte corto o largo.

   A corto plazo importa la trayectoria exacta; a largo plazo importan el equilibrio y la tendencia. Lo veremos en el Tema 27.

05 · Representación en Python

El reloj continuo en una lista de tiempos

En Python no podemos guardar infinitos instantes, pero sí una malla fina que los aproxime: [0, dt, 2·dt, …, T]. Con dt = 0,1 la malla tiene 121 puntos en [0, 12]; con dt = 2 solo 7. La curva real vive entre ellos.

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


print("dt=2  :", malla_temporal(6, 2))
print("puntos con dt=0.5:", len(malla_temporal(6, 0.5)))

Probá con dt = 0,1: ¿cuántos puntos hay en [0, 6]? ¿Qué pasa si dt no divide exacto a T?

Integrar una tasa constante

Con tasa fija, la solución exacta es una recta x(t) = x0 + tasa·t. Euler con cualquier dt la recupera exacta; la diferencia aparece cuando la tasa depende del estado (Temas 15–16). Por ahora, comparemos malla gruesa y fina sobre la misma recta:

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


print(euler_tasa_constante(10, 1, 4, dt=2))
print(euler_tasa_constante(10, 1, 4, dt=0.5)[-1])

06 · Exploración

Laboratorio: dt grueso frente a dt fino

La curva dorada es la solución exacta continua x(t) = x0 + tasa·t. La escalera teal es Euler con tu paso dt: con tasa constante coinciden en los nodos, pero mirá qué pasa con la forma entre ellos y qué lejos queda la escalera cuando el paso es grande.

La recta dorada existe en todo instante; la escalera teal solo conoce los nodos. Entre nodos, Euler supone tasa congelada: con dt grande el dibujo miente aunque el valor final coincida.

Preguntas para explorar

1. Con tasa +1 y dt = 4, ¿el valor final es correcto? ¿Y la forma entre nodos?
2. Poné la tasa en 0. ¿Cuántos nodos hacen falta para dibujar bien una horizontal?
3. Si dt no divide a T = 12 (por ejemplo 5), ¿qué hace el último paso?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: contar nodos

Sin ejecutar primero: ¿cuántos nodos tiene la malla [0, 12] con dt = 3? ¿Y con dt = 0,5? Después comprobalo.

def cantidad_nodos(t_final, dt):
    n = 0
    t = 0.0
    while t < t_final + 1e-9:
        n += 1
        t += dt
    return n


print(cantidad_nodos(12, 3))
print(cantidad_nodos(12, 0.5))

Ejercicio 2: exacto frente a Euler

Completá la comparación para tasa −0,5 desde x0 = 10 hasta T = 6 con dt = 2. ¿Coinciden?

def comparar(x0, tasa, t_final, dt):
    exacto = x0 + tasa * t_final
    x, t = x0, 0.0
    while t < t_final - 1e-9:
        x = x + tasa * dt
        t += dt
    return exacto, x


print(comparar(10, -0.5, 6, 2))

Ejercicio 3: recortar el último paso

Escribí una malla que nunca se pase de T: si el paso siguiente excede el horizonte, recortalo. Probala con T = 12 y dt = 5.

def malla_recortada(t_final, dt):
    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_recortada(12, 5))

09 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos las variables de estado continuas: los niveles que varían en cada instante y cómo elegirlos bien.