Data update

Task/Euler-method/Ada/euler-method-1.adb

@@ -0,0 +1,11 @@
+generic
+   type Number is digits <>;
+package Euler is
+   type Waveform is array (Integer range <>) of Number;
+   function Solve
+            (  F      : not null access function (T, Y : Number) return Number;
+               Y0     : Number;
+               T0, T1 : Number;
+               N      : Positive
+            )  return Waveform;
+end Euler;

Task/Euler-method/Ada/euler-method-2.adb

@@ -0,0 +1,17 @@
+package body Euler is
+   function Solve
+            (  F      : not null access function (T, Y : Number) return Number;
+               Y0     : Number;
+               T0, T1 : Number;
+               N      : Positive
+            )  return Waveform is
+      dT : constant Number := (T1 - T0) / Number (N);
+   begin
+      return Y : Waveform (0..N) do
+         Y (0) := Y0;
+         for I in 1..Y'Last loop
+            Y (I) := Y (I - 1) + dT * F (T0 + dT * Number (I - 1), Y (I - 1));
+         end loop;
+      end return;
+   end Solve;
+end Euler;

Task/Euler-method/Ada/euler-method-3.adb

@@ -0,0 +1,18 @@
+with Ada.Text_IO;  use Ada.Text_IO;
+with Euler;
+
+procedure Test_Euler_Method is
+   package Float_Euler is new Euler (Float);
+   use Float_Euler;
+
+   function Newton_Cooling_Law (T, Y : Float) return Float is
+   begin
+      return -0.07 * (Y - 20.0);
+   end Newton_Cooling_Law;
+
+   Y : Waveform := Solve (Newton_Cooling_Law'Access, 100.0, 0.0, 100.0, 10);
+begin
+   for I in Y'Range loop
+      Put_Line (Integer'Image (10 * I) & ":" & Float'Image (Y (I)));
+   end loop;
+end Test_Euler_Method;

Task/Euler-method/COBOL/euler-method.cob

@@ -0,0 +1,45 @@
+       DELEGATE-ID func.
+       PROCEDURE DIVISION USING VALUE t AS FLOAT-LONG
+           RETURNING ret AS FLOAT-LONG.
+       END DELEGATE.
+
+       CLASS-ID. MainClass.
+
+       78  T0                     VALUE 100.0.
+       78  TR                     VALUE 20.0.
+       78  k                      VALUE 0.07.
+
+       01  delta-t                INITIALIZE ONLY STATIC
+                                  FLOAT-LONG OCCURS 3 VALUES 2.0, 5.0, 10.0.
+
+       78  n                      VALUE 100.
+
+       METHOD-ID NewtonCooling STATIC.
+       PROCEDURE DIVISION USING VALUE t AS FLOAT-LONG
+               RETURNING ret AS FLOAT-LONG.
+           COMPUTE ret = - k * (t - TR)
+       END METHOD.
+
+       METHOD-ID Main STATIC.
+           DECLARE f AS TYPE func
+           SET f TO METHOD self::NewtonCooling
+
+           DECLARE delta-t-len AS BINARY-LONG
+           MOVE delta-t::Length TO delta-t-len
+           PERFORM VARYING i AS BINARY-LONG FROM 1 BY 1
+                   UNTIL i > delta-t-len
+               DECLARE elt AS FLOAT-LONG = delta-t (i)
+               INVOKE TYPE Console::WriteLine("delta-t = {0:F4}", elt)
+               INVOKE self::Euler(f, T0, n, elt)
+           END-PERFORM
+       END METHOD.
+
+       METHOD-ID Euler STATIC.
+       PROCEDURE DIVISION USING VALUE f AS TYPE func, y AS FLOAT-LONG,
+               n AS BINARY-LONG, h AS FLOAT-LONG.
+           PERFORM VARYING x AS BINARY-LONG FROM 0 BY h UNTIL x >= n
+               INVOKE TYPE Console::WriteLine("x = {0:F4}, y = {1:F4}", x, y)
+               COMPUTE y = y + h * RUN f(y)
+           END-PERFORM
+       END METHOD.
+       END CLASS.

Task/Euler-method/PowerShell/euler-method.ps1

@@ -0,0 +1,43 @@
+function euler (${f}, ${y}, $y0, $t0, $tEnd) {
+    function f-euler ($tn, $yn, $h)  {
+        $yn + $h*(f $tn $yn)
+    }
+    function time ($t0, $h, $tEnd)  {
+        $end = [MATH]::Floor(($tEnd - $t0)/$h)
+        foreach ($_ in 0..$end) { $_*$h + $t0 }
+    }
+    $time = time $t0 10 $tEnd
+    $time5 = time $t0 5 $tEnd
+    $time2 = time $t0 2 $tEnd
+    $yn10 = $yn5 = $yn2 = $y0
+    $i2 = $i5 = 0
+    foreach ($tn10 in $time) {
+        while($time2[$i2] -ne $tn10) {
+            $i2++
+            $yn2 = (f-euler $time2[$i2] $yn2 2)
+        }
+        while($time5[$i5] -ne $tn10) {
+            $i5++
+            $yn5 = (f-euler $time5[$i5] $yn5 5)
+        }
+        [pscustomobject]@{
+            t = "$tn10"
+            Analytical = "$("{0:N5}" -f (y $tn10))"
+            "Euler h = 2" = "$("{0:N5}" -f $yn2)"
+            "Euler h = 5" = "$("{0:N5}" -f $yn5)"
+            "Euler h = 10" = "$("{0:N5}" -f $yn10)"
+            "Error h = 2" = "$("{0:N5}" -f [MATH]::abs($yn2 - (y $tn10)))"
+            "Error h = 5" = "$("{0:N5}" -f [MATH]::abs($yn5 - (y $tn10)))"
+            "Error h = 10" = "$("{0:N5}" -f [MATH]::abs($yn10 - (y $tn10)))"
+        }
+        $yn10 = (f-euler $tn10 $yn10 10)
+    }
+}
+$k, $yr, $y0, $t0, $tEnd = 0.07, 20, 100, 0, 100
+function f ($t, $y)  {
+    -$k *($y - $yr)
+}
+function y ($t)  {
+    $yr + ($y0 - $yr)*[MATH]::Exp(-$k*$t)
+}
+euler f y $y0 $t0 $tEnd | Format-Table -AutoSize

Task/Euler-method/Rebol/euler-method.rebol

@@ -0,0 +1,34 @@
+Rebol [
+    title: "Rosetta code: Euler method"
+    file:  %Euler_method.r3
+    url:   https://rosettacode.org/wiki/Euler_method
+]
+
+euler: func[
+    "Euler's method for Newton's cooling law, with formatted comparison"
+    step      [integer!] "time step in seconds"
+    precision [decimal!] "rounding granularity for printed numbers"
+][
+    print ["^/STEP:" step]
+    print "Time  Euler      Analytic"
+    print "-------------------------"
+
+    ;; Initialize:
+    ;; b: upper time bound (seconds) — here we reuse the initial temperature value 100
+    ;; y: the current Euler-approximated temperature; initial condition T(0) = 100
+    b: y: 100
+    for time 0 b step [
+        printf [-3 " | " 9 "| "] reduce [
+            time
+            round/to y precision
+            round/to (20 + (80 * exp (-0.07 * time))) precision
+        ]
+        ;; Euler step update:
+        ;; This applies the discrete forward Euler update using the ODE's RHS
+        y: y + (step * (-0.07 * (y - 20)))
+    ]
+]
+;; Run three experiments with different step sizes
+euler 2  0.0001
+euler 5  0.0001
+euler 10 0.0001