Hoe een Pendulum je verschillende vergelijkingen leert

Begin met wat je kunt zien

Hang een gewicht aan een touw. Trek het aan één kant. Laat los. Het schommelt.

Je hebt net een systeem gecreëerd dat wordt beheerst door een differentiaalvergelijking:

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

θ is de hoek. ω is de hoeksnelheid. g de zwaartekracht (9,81 m/s2). L is de tekenreekslengte. Deze twee lijnen zeggen: de hoek verandert bij een snelheid gelijk aan de snelheid, en de snelheid verandert bij een snelheid die afhankelijk is van de zwaartekracht, lengte en de huidige hoek.

Het probleem: we kunnen deze vergelijking niet precies oplossen. De sin(θ) maakt het niet lineair. Er is geen formule die je θ geeft op elk moment t. Dus we benaderen we stappen vooruit in kleine stappen, het berekenen van de volgende staat van de huidige.

Dat doet een ODE-oplosser. En er zijn betere en slechtere manieren om het te doen.

De Euler-methode: duidelijk maar fout

Het eenvoudigste idee: als ik de staat nu ken, en ik ken de snelheid van verandering, kan ik de staat een kleine tijdstap later inschatten.

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

Dit is Euler's methode. Het is alsof je door mist loopt: je kunt een stap vooruit zien, dus je zet die stap, en kijk dan nog eens. In code:

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

Het probleem: de methode van Euler is eerste orde nauwkeurig. Dat betekent dat als je de stapgrootte halveert, je de fout halveert. Voor een slinger, deze fout accumuleert de gesimuleerde slinger langzaam krijgt energie en schommelt breder en breder. Na een paar minuten draait het rondjes. Een echte slinger doet dit nooit.

RK4: Het werkpaard

In 1901 publiceerden Carl Runge en Martin Kutta een betere methode. In plaats van te kijken naar het tempo van verandering eenmaal per stap, kijk er vier keer naar:

1. Meet de helling aan het begin van stap → k1
2. Stap halverwege met k1, meet de helling daar → k2
3. Stap halverwege met k2, meet opnieuw → k3
4. Stap naar het einde met k3, meet nog één keer → k4
5. Combineer: gewogen gemiddelde (k1 + 2k2 + 2k3 + k4) / 6

Dit is de vierde orde nauwkeurig. Halveer de stapgrootte en de fout daalt met een factor 16. De slinger spaart energie correct voor duizenden schommels.

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

Dit is de methode die PinePaper gebruikt voor slinger-, veer- en Van der Pol simulaties. Het is dezelfde methode die gebruikt wordt in lucht- en ruimtevaart traject berekeningen. 22 regels code.

Waarom dit buiten de natuurkunde om gaat

De slinger is een leervoorbeeld. Maar dezelfde techniek stap naar voren, meten, correct

• Bevolkingsgroei: dx/dt = r·x·(1 - x/K). Logistische groei met draagvermogen. Dezelfde oplossing.
• Chemische reacties: concentraties veranderen in verhouding tot de huidige concentraties. Dezelfde oplossing.
• Neurale netwerken: gradiëntdaling is een gediscretiseerde ODE. Elke trainingstap is een Euler stap langs het verliesoppervlak.
• ** Economie**: renteverbindingen continu via dy/dt = r·y. Exponentiële groei is de eenvoudigste ODE.
• Animatie timing: versoepelingscurves zijn oplossingen voor ODE's met een verendemper. De "elastische" en "bounce" versoepelingen in CSS zijn fysieke simulaties.

De wiskunde verandert niet. Het domein wel. Dat is wat het een taal maakt. Dezelfde grammatica beschrijft schapen tellen, slinger schommels, en neurale netwerk training.

Probeer het zelf maar

Open PinePaper en selecteer de Dynamic System generator. Kies "pendulum." De bob schommelt. Verander nu de parameters:

• Verhoog de zwaartekracht → snellere schommel (kortere periode)
• Verhoog staaflengte → langzamer schommelen (langere periode)
• Begin bij een grotere hoek → kijk hoe de periode toeneemt (niet-lineair effect dat het leerboek kleine hoek benadering mist)

Elke verandering die je maakt is een meting. Je veranderde een parameter en zag het resultaat. De RK4-oplosser recomputeerde 30 frames per seconde, en de slinger liet zien wat de vergelijking voorspelt.

Dat is het hele punt. Wiskunde is meten. PinePaper maakt het zichtbaar.

{widget: pendulum-lab}

Referenties

• Slager, J.C. (2016). Numerieke methoden voor gewone differentiaalvergelijkingen (3rd ed.). Wiley.
• Dormand, J.R. & Prince, P.J. (1980). Een familie van ingebouwde Runge-Kutta formules. * Journal of Computational and Applied Mathematics*, 6(1), 19-26.
• Euler, L. (1768). * Institutionum calculi integralis*, Vol. 1.
• Hairer, E., Nørsett, S.P., & Wanner, G. (1993). * Solving Ordinary Differential Equations I: Nonstiff Problems* (2nd ed.). Springer.
• Kutta, W. (1901). Beitrag zur näherungsweisen Integratie totaler Differentialgleichungen. Zeitschrift für Mathematik und Physik, 46, 435-453.
• Newton, I. (1687). Philosophiae Naturalis Principia Mathematica. London: Joseph Streater.
• Runge, C. (1895). Über die numerische Auflösung von Differenialgleichungen. Mathematische Annalen, 46(2), 167-178.
• Strogatz, S.H. (2015). Nonlineaire Dynamics and Chaos (2nd ed.). Westview Press.

---

• PinePaper's ODE-oplosser dekt Euler, RK4, en adaptive Dormand-Prince RK45 in ongeveer 200 lijnen. Probeer de slingersimulatie gratis op pinepaper.studio/editor.*