Verlet Integration in Nim (algorithm-archivists#598)

Author: c252

contents/verlet_integration/code/nim/verlet.nim

@@ -0,0 +1,56 @@
+proc verlet(pos_in, acc, dt: float): float =
+  var
+    pos: float = pos_in
+    prevPos: float = pos
+    time: float = 0.0
+    tempPos: float
+
+  while pos > 0.0:
+    time += dt
+    tempPos = pos
+    pos = pos * 2 - prevPos + acc * dt * dt
+    prevPos = tempPos
+
+  return time
+
+proc stormerVerlet(pos_in, acc, dt: float): (float, float) =
+  var
+    pos: float = pos_in
+    prevPos: float = pos
+    time: float = 0.0
+    vel: float = 0.0
+    tempPos: float
+
+  while pos > 0.0:
+    time += dt
+    tempPos = pos
+    pos = pos * 2 - prevPos + acc * dt * dt
+    prevPos = tempPos
+
+    vel += acc * dt
+
+  return (time, vel)
+
+proc velocityVerlet(pos_in, acc, dt: float): (float, float) =
+  var
+    pos: float = pos_in
+    time: float = 0.0
+    vel: float = 0.0
+
+  while pos > 0.0:
+    time += dt
+    pos += vel * dt + 0.5 * acc * dt * dt
+    vel += acc * dt
+
+  return (time, vel)
+
+let timeV = verlet(5.0, -10.0, 0.01)
+echo "Time for Verlet integration is: ", timeV
+
+let (timeSV, velSV) = stormerVerlet(5.0, -10.0, 0.01)
+echo "Time for Stormer Verlet integration is: ", timeSV
+echo "Velocity for Stormer Verlet integration is: ", velSV
+
+let (timeVV, velVV) = velocityVerlet(5.0, -10.0, 0.01)
+echo "Time for velocity Verlet integration is: ", timeVV
+echo "Velocity for velocity Verlet integration is: ", velVV

contents/verlet_integration/verlet_integration.md

@@ -67,6 +67,8 @@ Unfortunately, this has not yet been implemented in LabVIEW, so here's Julia cod
 [import:18-42, lang:"asm-x64"](code/asm-x64/verlet.s)
 {% sample lang="kotlin" %}
 [import:3-15, lang:"kotlin"](code/kotlin/verlet.kt)
+{% sample lang="nim" %}
+[import:1-14, lang:"nim"](code/nim/verlet.nim)
 {% endmethod %}
 
 Now, obviously this poses a problem; what if we want to calculate a term that requires velocity, like the kinetic energy, $$\frac{1}{2}mv^2$$? In this case, we certainly cannot get rid of the velocity! Well, we can find the velocity to $$\mathcal{O}(\Delta t^2)$$ accuracy by using the Stormer-Verlet method, which is the same as before, but we calculate velocity like so
@@ -121,6 +123,8 @@ Unfortunately, this has not yet been implemented in LabVIEW, so here's Julia cod
 [import:44-71, lang:"asm-x64"](code/asm-x64/verlet.s)
 {% sample lang="kotlin" %}
 [import:17-30, lang:"kotlin"](code/kotlin/verlet.kt)
+{% sample lang="nim" %}
+[import:16-32, lang:"nim"](code/nim/verlet.nim)
 {% endmethod %}
 
 
@@ -189,6 +193,8 @@ Unfortunately, this has not yet been implemented in LabVIEW, so here's Julia cod
 [import:73-101, lang:"asm-x64"](code/asm-x64/verlet.s)
 {% sample lang="kotlin" %}
 [import:32-42, lang:"kotlin"](code/kotlin/verlet.kt)
+{% sample lang="nim" %}
+[import:34-45, lang:"nim"](code/nim/verlet.nim)
 {% endmethod %}
 
 Even though this method is more widely used than the simple Verlet method mentioned above, it unforunately has an error term of $$\mathcal{O}(\Delta t^2)$$, which is two orders of magnitude worse. That said, if you want to have a simulaton with many objects that depend on one another --- like a gravity simulation --- the Velocity Verlet algorithm is a handy choice; however, you may have to play further tricks to allow everything to scale appropriately. These types of simulatons are sometimes called *n-body* simulations and one such trick is the Barnes-Hut algorithm, which cuts the complexity of n-body simulations from $$\sim \mathcal{O}(n^2)$$ to $$\sim \mathcal{O}(n\log(n))$$.
@@ -248,6 +254,8 @@ Submitted by P. Mekhail
 [import, lang:"asm-x64"](code/asm-x64/verlet.s)
 {% sample lang="kotlin" %}
 [import, lang:"kotlin"](code/kotlin/verlet.kt)
+{% sample lang="nim" %}
+[import, lang="nim"](code/nim/verlet.nim)
 {% endmethod %}