September 2017 Update

Task/Runge-Kutta-method/00META.yaml

@@ -1,2 +0,0 @@
----
-note: Runge-Kutta method

Task/Runge-Kutta-method/Groovy/runge-kutta-method.groovy

@@ -0,0 +1,24 @@
+class Runge_Kutta{
+static void main(String[] args){
+def y=1.0,t=0.0,counter=0;
+def dy1,dy2,dy3,dy4;
+def real;
+while(t<=10)
+{if(counter%10==0)
+{real=(t*t+4)*(t*t+4)/16;
+println("y("+t+")="+ y+ " Error:"+ (real-y));
+}
+
+dy1=dy(dery(y,t));
+dy2=dy(dery(y+dy1/2,t+0.05));
+dy3=dy(dery(y+dy2/2,t+0.05));
+dy4=dy(dery(y+dy3,t+0.1));
+
+y=y+(dy1+2*dy2+2*dy3+dy4)/6;
+t=t+0.1;
+counter++;
+}
+}
+static def dery(def y,def t){return t*(Math.sqrt(y));}
+static def dy(def x){return x*0.1;}
+}

Task/Runge-Kutta-method/Kotlin/runge-kutta-method.kotlin

@@ -0,0 +1,35 @@
+// version 1.1.2
+
+typealias Y  = (Double) -> Double
+typealias Yd = (Double, Double) -> Double
+
+fun rungeKutta4(t0: Double, tz: Double, dt: Double, y: Y, yd: Yd) {
+    var tn = t0
+    var yn = y(tn)
+    val z = ((tz  - t0) / dt).toInt()
+    for (i in 0..z) {
+        if (i % 10 == 0) {
+            val exact = y(tn)
+            val error = yn - exact
+            println("%4.1f  %10f  %10f  %9f".format(tn, yn, exact, error))
+        }
+        if (i == z) break
+        val dy1 = dt * yd(tn, yn)
+        val dy2 = dt * yd(tn + 0.5 * dt, yn + 0.5 * dy1)
+        val dy3 = dt * yd(tn + 0.5 * dt, yn + 0.5 * dy2)
+        val dy4 = dt * yd(tn + dt, yn + dy3)
+        yn += (dy1 + 2.0 * dy2 + 2.0 * dy3 + dy4) / 6.0
+        tn += dt
+    }
+}
+
+fun main(args: Array<String>) {
+    println("  T        RK4        Exact      Error")
+    println("----  ----------  ----------  ---------")
+    val y = fun(t: Double): Double {
+        val x = t * t + 4.0
+        return x * x / 16.0
+    }
+    val yd = fun(t: Double, yt: Double) = t * Math.sqrt(yt)
+    rungeKutta4(0.0, 10.0, 0.1, y, yd)
+}

Task/Runge-Kutta-method/Phix/runge-kutta-method.phix

@@ -0,0 +1,16 @@
+constant dt = 0.1
+atom y = 1.0
+printf(1,"  x    true/actual y   calculated y    relative error\n")
+printf(1," ---   -------------   -------------   --------------\n")
+for i=0 to 100 do
+    atom t = i*dt
+    if integer(t) then
+        atom act = power(t*t+4,2)/16
+        printf(1,"%4.1f  %14.9f  %14.9f   %.9e\n",{t,act,y,abs(y-act)})
+    end if
+    atom k1 = t*sqrt(y),
+         k2 = (t+dt/2)*sqrt(y+dt/2*k1),
+         k3 = (t+dt/2)*sqrt(y+dt/2*k2),
+         k4 = (t+dt)*sqrt(y+dt*k3)
+    y += dt*(k1+2*(k2+k3)+k4)/6
+end for

Task/Runge-Kutta-method/Rust/runge-kutta-method.rust

@@ -0,0 +1,36 @@
+fn runge_kutta4( fx: &Fn(f64, f64) -> f64, x: f64, y: f64, dx: f64 ) -> f64 {
+    let k1 = dx * fx( x, y );
+    let k2 = dx * fx( x + dx / 2.0, y + k1 / 2.0 );
+    let k3 = dx * fx( x + dx / 2.0, y + k2 / 2.0 );
+    let k4 = dx * fx( x + dx, y + k3 );
+
+    y + ( k1 + 2.0 * k2 + 2.0 * k3 + k4 ) / 6.0
+}
+
+fn f(x: f64, y: f64) -> f64 {
+    x * y.sqrt()
+}
+
+fn actual(x: f64) -> f64 {
+    (1.0/16.0) * (x*x+4.0).powi(2)
+}
+
+fn main() {
+    let mut y = 1.0;
+    let mut x = 0.0;
+    let step = 0.1;
+    let mut steps = 0;
+    let max_steps = 101;
+    let sample_every_n = 10;
+    while steps < max_steps {
+        if steps % sample_every_n == 0 {
+            println!("y({}):\t{:.10}\t\t {:E}", x, y, actual(x) - y)
+        }
+
+        y = runge_kutta4(&f, x, y, step);
+
+        x = ((x * 10.0) + (step * 10.0)) / 10.0;
+        steps += 1;
+
+    }
+}

Task/Runge-Kutta-method/Zkl/runge-kutta-method.zkl

@@ -0,0 +1,16 @@
+fcn yp(t,y) { t * y.sqrt() }
+fcn exact(t){ u:=0.25*t*t + 1.0; u*u }
+
+fcn rk4_step([(y,t)],h){
+   k1:=h * yp(t,y);
+   k2:=h * yp(t + 0.5*h, y + 0.5*k1);
+   k3:=h * yp(t + 0.5*h, y + 0.5*k2);
+   k4:=h * yp(t + h, y + k3);
+   T(y + (k1+k4)/6.0 + (k2+k3)/3.0, t + h);
+}
+
+fcn loop(h,n,[(y,t)]){
+   if(n % 10 == 1)
+      print("t = %f,\ty = %f,\terr = %g\n".fmt(t,y,(y - exact(t)).abs()));
+   if(n < 102) return(loop(h,(n+1),rk4_step(T(y,t),h))) //tail recursion
+}