Ecuaciones de primer orden

01 · Punto de partida

Una derivada, una historia

Las ecuaciones de primer orden solo piden la primera derivada: dx/dt = f(x, t). Con eso alcanza para tanques, enfriamientos, crecimientos y decaimientos: la velocidad depende del nivel y quizás del tiempo, pero no de aceleraciones.

Son el caballo de batalla del curso: se entienden con pendientes, se resuelven a mano en los casos lineales y se integran siempre con Euler y Runge-Kutta.

• ¿La regla usa x, t, ambos o ninguno?
• ¿Tiene solución cerrada o pedimos ayuda numérica?
• ¿Qué error comete Euler con mi dt?
• ¿El equilibrio es atractor o repulsor?

02 · Definición

¿Qué es una EDO de primer orden?

Solo aparece la primera derivada. Tres sabores según qué usa f:

Lineal no significa recta en el tiempo: significa recta en el plano (x, f). La solución N(t) del tanque lineal es una curva que se suaviza, no una recta.

03 · Anatomía

Solución analítica y campo de pendientes

La solución tiene dos partes: el régimen que impone la entrada y el transitorio que olvida el inicio:

Solución lineal

N(t) = N* + (N₀ − N*)·e^(−k·t): equilibrio más desvío que decae.

Campo de pendientes

En cada (t, x) un segmentito con pendiente f: las curvas lo siguen como vías.

Equilibrio

f(x*) = 0: horizontal que atrae (k > 0) o repele (r > 0 en P = 0).

Euler

x ← x + f(x, t)·dt: congela la pendiente en cada nodo y salta.

04 · Primer orden en el curso

Casi todo el curso vive aquí

Cada modelo clásico es un caso de primer orden:

1. 1
   Tanque lineal.

   dN/dt = q − k·N. Exacta conocida: referencia de error.

2. 2
   Enfriamiento.

   dT/dt = −k·(T − T_amb). Misma forma, otro cero.

3. 3
   Exponencial.

   dP/dt = r·P. Exacta P₀·e^(r·t): Euler siempre por debajo o por arriba.

4. 4
   Logístico.

   dP/dt = r·P·(1 − P/K). Primer orden no lineal: sin fórmula simple a mano.

5. 5
   Con entrada variable.

   dN/dt = q(t) − k·N. Primer orden no autónomo: solo numérico en general.

05 · Representación en Python

Exacta y Euler lado a lado

En Python conviven la fórmula cerrada (cuando existe) y el bucle de Euler (siempre). Compararlas mide el error del método.

import math


def exacta(q, k, n0, t):
    neq = q / k
    return neq + (n0 - neq) * math.exp(-k * t)


def euler(q, k, n0, t_final, dt):
    n, t = n0, 0.0
    while t < t_final - 1e-9:
        n = n + (q - k * n) * dt
        t += dt
    return n


print("exacta:", round(exacta(3, 0.2, 2, 10), 3))
print("euler :", round(euler(3, 0.2, 2, 10, dt=1.0), 3))

Con dt = 1 el error ronda 0,1: visible pero pequeño. Con dt = 2 crece; con dt = 0,1 casi desaparece.

Medir el error

El error absoluto en el horizonte es la vara del método:

def error(q, k, n0, t_final, dt):
    return abs(exacta(q, k, n0, t_final) - euler(q, k, n0, t_final, dt))


for dt in [2, 1, 0.5, 0.25]:
    print(dt, "→", round(error(3, 0.2, 2, 10, dt), 4))

06 · Exploración

Laboratorio: exacta frente a Euler con tu dt

Tanque lineal con tu q, tu k y tu dt. La dorada es la exacta continua; la teal es Euler con nodos marcados. La banda es el error en cada instante: angostala achicando dt.

La poligonal teal corta a la exacta: Euler subestima o sobrestima según el lado del equilibrio. Con dt grande los nodos se separan y el error crece.

Preguntas para explorar

1. Con dt = 4, ¿Euler queda por arriba o por debajo de la exacta partiendo de N₀ = 2?
2. Subí k a 0,6 con el mismo dt. ¿El error crece o se mantiene? ¿Por qué?
3. ¿Qué dt elegirías para error menor que 0,01 con k = 0,2?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: clasificar el orden

¿Cuál es de primer orden? Pensalo por la derivada mayor y después verificá con la lista.

casos = {
    "dN/dt = 3 - 0.2*N": 1,
    "d2x/dt2 = -k*x": 2,
    "dP/dt = r*P*(1 - P/K)": 1,
}
for edo, orden in casos.items():
    print(edo, "→ orden", orden)

Ejercicio 2: exacta a mano

Con q = 4, k = 0,5 y N₀ = 0, ¿cuánto vale N(2)? Calculalo a mano y comprobalo.

import math


def exacta(q, k, n0, t):
    return q / k + (n0 - q / k) * math.exp(-k * t)


print(round(exacta(4, 0.5, 0, 2), 3))

Ejercicio 3: barrido de dt

Escribí un barrido que muestre cómo cae el error al achicar dt. Probalo con q = 3, k = 0,2, N₀ = 2, T = 10.

import math


def exacta(q, k, n0, t):
    return q / k + (n0 - q / k) * math.exp(-k * t)


def euler(q, k, n0, t_final, dt):
    n, t = n0, 0.0
    while t < t_final - 1e-9:
        n = n + (q - k * n) * dt
        t += dt
    return n


for dt in [2, 1, 0.5, 0.25, 0.1]:
    e = abs(exacta(3, 0.2, 2, 10) - euler(3, 0.2, 2, 10, dt))
    print(dt, "→", round(e, 4))

09 · Síntesis

Ideas para recordar

En el próximo tema subiremos a orden superior: cuando aparecen aceleraciones y oscilaciones.