Come un Pendulum ti insegna Equazioni differenziali

Inizia con quello che puoi vedere

Impicca un peso da una stringa. Tiralo su un lato. Lasciami andare. Sta oscillando.

Hai appena creato un sistema governato da un'equazione differenziale:

dθ/dt = ω dω/dt = -(g/L) · sin(θ)

θ è l'angolo. ω è la velocità angolare. g è gravità (9,81 m/s2). L è la lunghezza della corda. Queste due linee dicono: l'angolo cambia ad una velocità pari alla velocità, e la velocità cambia ad una velocità che dipende dalla gravità, dalla lunghezza e dall'angolo corrente.

Il problema: non possiamo risolvere esattamente questa equazione. La sin(θ) lo rende non lineare. Non c'è formula che ti dà θ in qualsiasi momento t. Quindi approssimativo — facciamo un passo avanti in piccoli incrementi, calcolando lo stato successivo da quello attuale.

E' quello che fa un risolutore ODE. E ci sono modi migliori e peggiori per farlo.

Il metodo Euler: Obvious ma Flawed

L'idea più semplice: se conosco lo stato ora, e conosco il tasso di cambiamento, posso stimare lo stato un piccolo passo dopo.

next_angle = current_angle + velocity × dt
next_velocity = current_velocity + acceleration × dt

Questo è il metodo di Euler. È come camminare attraverso la nebbia: si può vedere un passo avanti, così si fa quel passo, poi guardare di nuovo. In codice:

function euler(f, t, y, dt) {
  const dy = f(t, y);
  return [
    y[0] + dt * dy[0],
    y[1] + dt * dy[1]
  ];
}

Il problema: il metodo di Euler è accurato al primo ordine. Ciò significa che se si halve la dimensione del passo, si halve l'errore. Per un pendolo, questo errore si accumula — il pendolo simulato acquisisce lentamente energia e oscillazioni più ampie e più ampie. Dopo qualche minuto, gira in pieno cerchio. Un vero pendolo non lo fa mai.

RK4: Il cavallo da lavoro

Nel 1901 Carl Runge e Martin Kutta pubblicarono un metodo migliore. Invece di guardare il tasso di cambiamento una volta per passo, guardarlo quattro volte:

1. Misurare la pendenza all'inizio della fase → k1
2. Passo a metà strada utilizzando k1, misurare la pendenza lì → k2
3. Passo a metà strada utilizzando k2, misurare di nuovo → k3
4. Passo alla fine utilizzando k3, misurare ancora una volta → k4
5. Combinazione: media ponderata (k1 + 2k2 + 2k3 + k4) / 6

Questo è accurato al quarto ordine. Abbassare la dimensione del passo e l'errore scende di un fattore di 16. Il pendolo conserva energia correttamente per migliaia di altalene.

function rk4(f, t, y, dt) {
  const k1 = f(t, y);
  const k2 = f(t + dt/2, [y[0] + dt/2 * k1[0], y[1] + dt/2 * k1[1]]);
  const k3 = f(t + dt/2, [y[0] + dt/2 * k2[0], y[1] + dt/2 * k2[1]]);
  const k4 = f(t + dt,   [y[0] + dt   * k3[0], y[1] + dt   * k3[1]]);
  return [
    y[0] + (dt/6) * (k1[0] + 2*k2[0] + 2*k3[0] + k4[0]),
    y[1] + (dt/6) * (k1[1] + 2*k2[1] + 2*k3[1] + k4[1])
  ];
}

Questo è il metodo PinePaper utilizza per simulazioni di pendolo, primavera-massa e Van der Pol. E' lo stesso metodo usato nei calcoli traiettoria aerospaziale. 22 linee di codice.

Perché questo Matters Fuori Fisica

Il pendolo è un esempio di insegnamento. Ma la stessa tecnica — passo avanti, misura, corretto — si applica ovunque tu abbia un tasso di cambiamento:

• ** Crescita della popolazione **: dx/dt = r·x·(1 - x/K). Crescita logistica con capacità di trasporto. Stesso risolutore.
• ** Reazioni chimiche**: le concentrazioni cambiano a tassi proporzionali alle concentrazioni correnti. Stesso risolutore.
• Reti neurali: la discesa gradiente è un ODE discretizzato. Ogni fase di allenamento è un passo Euler lungo la superficie di perdita.
• **Economia **: composti d'interesse continuamente tramite dy/dt = r·y. La crescita esponenziale è la più semplice ODE.
• ** Tempismo di animazione**: le curve di easing sono soluzioni per gli ODE a molla. Gli easing "elastici" e "bounce" in CSS sono simulazioni fisiche.

La matematica non cambia. Il dominio lo fa. Questo è ciò che lo rende una lingua — la stessa grammatica descrive il conteggio delle pecore, le oscillazioni del pendolo, e la formazione della rete neurale.

Provatelo voi stessi

Aprire PinePaper e selezionare il generatore di sistema dinamico. Scegli "pendulum". Le oscillazioni. Ora cambia i parametri:

• Aumentare la gravità → oscillazione più veloce (periodo breve)
• Aumentare la lunghezza dell'asta → oscillazione più lenta (periodo più lungo)
• Iniziare ad un angolo più grande → guardare come aumenta il periodo (effetto non lineare che manca l'approssimazione del libro di testo piccolo angolo)

Ogni cambiamento che fai è una misura. Hai cambiato un parametro e osservato il risultato. Il risolutore RK4 ha riscosso 30 fotogrammi al secondo, e il pendolo vi ha mostrato cosa prevede l'equazione.

E' questo il punto. La matematica è la misura. PinePaper lo rende visibile.

Referenze

• Macellaio, J.C. (2016). Metodi numerici per le equazioni differenziali ordinarie (3 ° ed.). Wiley.
• Dormand, J.R. & Prince, P.J. (1980). Una famiglia di formule Runge-Kutta incorporate. Journal of Computational and Applied Mathematics, 6(1), 19-26.
• Euler, L. (1768). Institutionum calculi integralis, Vol. 1. Impensis Academiae Imperialis Scientiarum.
• Hairer, E., Nørsett, S.P., & Wanner, G. (1993). Equazioni differenziali ordinarie I: Nonstiff Problems (2nd ed.). Springer.
• Kutta, W. (1901). Beitrag zur näherungsweisen Integration totaler Differentialgleichungen. Zeitschrift für Mathematik und Physik, 46, 435-453.
• Newton, I. (1687). Philosophiæ Naturalis Principia Mathematica. Joseph Streater.
• Runge, C. (1895). Über die numerische Auflösung von Differentialgleichungen. Mathematische Annalen, 46(2), 167-178.
• Strogatz, S.H. (2015). * Dinamica non lineare e Caos* (2a ed.). Westview Press.

---

Il risolutore ODE di PinePaper copre Euler, RK4, e l'adaptive Dormand-Prince RK45 in circa 200 linee. Prova la simulazione del pendolo gratuitamente a pinepaper.studio/editore.*