Hur ett pendelt lär dig differentierade ekvationer

Börja med vad du kan se

Häng en vikt från en sträng. Dra den till ena sidan. Låt gå. Svänger.

Du skapade bara ett system som styrs av en differentialekvation:

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

är vinkeln. är den vinkelformade hastigheten. g är gravitation (9,81 m/s2). L är stränglängden. Dessa två linjer säger: vinkeln ändras i en takt som motsvarar hastigheten, och hastigheten ändras i en takt som beror på gravitation, längd och den nuvarande vinkeln.

Problemet: Vi kan inte lösa denna ekvation exakt. sin(θ) gör det olinjärt. Det finns ingen formel som ger dig θ när som helst. Så vi ungefär - vi går framåt i små steg, beräknar nästa tillstånd från den nuvarande.

Det är vad en ODE-lösare gör. Och det finns bättre och sämre sätt att göra det.

Euler-metoden: Uppenbar men bristfällig

Den enklaste idén: om jag känner staten nu, och jag vet förändringstakten, kan jag uppskatta staten ett litet steg senare.

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

Detta är Eulers metod. Det är som att gå genom dimma: du kan se ett steg framåt, så du tar det steget och sedan titta igen. I koden:

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

Problemet: Eulers metod är första ordningen korrekt. Det betyder att om du halverar stegstorleken, halverar du felet. För en pendel ackumuleras detta fel - den simulerade pendeln långsamt får energi och svängningar bredare och bredare. Efter några minuter spinner det i fulla cirklar. En riktig pendel gör det aldrig.

RK4: Workhorse

År 1901 publicerade Carl Runge och Martin Kutta en bättre metod. Istället för att titta på förändringstakten en gång per steg, titta på den fyra gånger:

1. Mät backen i början av steget → k1
2. Steg halvvägs med k1, mäta sluttningen där → k2
3. Steg halvvägs med k2, mät igen → k3
4. Steg till slutet med k3, mäta en gång till → k4
5. Kombinera: viktat genomsnitt (k1 + 2k2 + 2k3 + k4) / 6

Detta är fjärde ordningen korrekt. Halva stegstorleken och felet sjunker med en faktor på 16. Pendeln sparar energi korrekt för tusentals svängningar.

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])
  ];
}

Detta är metoden PinePaper använder för pendel, vårmassa och Van der Pol-simuleringar. Det är samma metod som används i luftrumsbanor. 22 rader av kod.

Varför det här är utanför fysik

Pendeln är ett undervisningsexempel. Men samma teknik - steg framåt, mäta, rätta - gäller var du än har en förändringstakt:

• Befolkningstillväxt: dx/dt= r·x·(1 - x/K). Logistisk tillväxt med bärförmåga. Samma lösare.
• *Kemiska reaktioner: koncentrationerna förändras i förhållande till nuvarande koncentrationer. Samma lösare.
• *Neural networks: gradient nedstigning är en diskretiserad ODE. Varje träningssteg är ett Euler steg längs förlustytan.
• *Ekonomi: intresseföreningar kontinuerligt via dy/dt = r·y. Exponentiell tillväxt är den enklaste ODE.
• ** Animation timing*: lätta kurvor är lösningar på vårdamper ODEs. De "elastiska" och "studsa" lättnader i CSS är fysiska simuleringar.

Mahen förändras inte. Domänen gör. Det är det som gör det till ett språk - samma grammatik beskriver fårräkning, pendelsvängningar och neural nätverksutbildning.

Prova det själv

Öppna PinePaper och välj Dynamic System generator. Välj "pendulum". Bob swings. Ändra nu parametrarna:

• Öka gravitationen → snabbare svängning (kortare period)
• Öka stavlängden → långsammare svängning (längre period)
• Börja i en större vinkel → se hur perioden ökar (nonlinear effekt som läroboken liten vinkel approximation missar)

Varje förändring du gör är en mätning. Du ändrade en parameter och observerade resultatet. RK4-lösaren rekomputerade 30 bilder per sekund, och pendeln visade dig vad ekvationen förutspår.

Det är hela poängen. Matematik är mätning. PinePaper gör det synligt.

Referenser

• Butcher, J.C. (2016). Numeriska metoder för vanliga skillnader (3rd ed.). Wiley.
• Dormand, J.R. & Prince, P.J. (1980). En familj av inbäddad Runge-Kutta formel. 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, SP, & Wanner, G. (1993). Solving Ordinary Differential Equations 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). Filosofiæ Naturalis Principia Mathematica*. London: Joseph Streater.
• Runge, C. (1895). Über dör numerische Auflösung von Differentialgleichungen. Mathematische Annalen, 46(2), 167-178.
• Strogatz, S.H. (2015). Nonlinear Dynamics and Chaos (2nd ed.) Westview Press.

---

PinePapers ODE-lösare täcker Euler, RK4 och adaptiv Dormand-Prince RK45 i cirka 200 linjer. Prova pendelsimulering gratis på [pinepaper.studio/editor] (/editor).