Euler method: Difference between revisions

{{Task|Mathematical operations}}

The ODE has to be provided in the following form:

 

 

with an initial value

 

 

 

 

then solve for <math>y(t+h)</math>:

 

 

which is the same as

 

 

The iterative solution rule is then:

 

 

 

 

 

 

or

 

 

The analytical solution, which we will compare to the numerical approximation, is

 

 

 

 

[[Image:Euler_Method_Newton_Cooling.png|center|750px]]

 

=={{header|Ada}}==

The solution is generic, usable for any floating point type. The package specification:

generic

type Number is digits <>;

) return Waveform;

end Euler;

The function Solve returns the solution of the differential equation for each of N+1 points, starting from the point T0. The implementation:

package body Euler is

function Solve

end Solve;

end Euler;

The test program:

with Ada.Text_IO; use Ada.Text_IO;

with Euler;

end loop;

end Test_Euler_Method;

Sample output:

<pre>

100: 2.00005E+01

</pre>

=={{header|ALGOL 68}}==

{{trans|D}} Note: This specimen retains the original [[#D|D]] coding style.

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

Approximates y(t) in y'(t)=f(t,y) with y(a)=y0 and

t=a..b and the step size h.

main: (

euler(newton cooling law, 100, 0, 100, 10)

Ouput:

<pre>

done

</pre>

 

=={{header|C}}==

#include <math.h>

 

 

return 0;

Analytic: 100.000 59.727 39.728 29.797 24.865 22.416 21.200 20.596 20.296 20.147 20.073

Step 2: 100.000 57.634 37.704 28.328 23.918 21.843 20.867 20.408 20.192 20.090 20.042

Step 5: 100.000 53.800 34.280 26.034 22.549 21.077 20.455 20.192 20.081 20.034 20.014

 

=={{header|C++}}==

{{trans|D}}

#include <iostream>

 

euler(newtonCoolingLaw, 100, 0, 100, 5);

euler(newtonCoolingLaw, 100, 0, 100, 10);

Last part of output:

<pre>

done

</pre>

 

=={{header|Clay}}==

 

import printer.formatter as pf;

 

}

}

 

Example output:

80 20.0052488

90 20.00157464

</pre>

 

=={{header|Common Lisp}}==

(defconstant true 'cl:t)

(shadow 't)

 

;; Set the initial values and increments of the iteration variables.

 

;; End the iteration when t reaches the end b of the time interval.

(euler #'newton-cooling 100 0 100 2)

(euler #'newton-cooling 100 0 100 5)

 

<pre>

 

=={{header|D}}==

 

double y = y0;

writefln("%.3f %.3f", t, y);

y += h * f(t, y);

}

}

 

void main() {

 

Last part of the output:

<pre>...

90.000 20.002

done</pre>

 

=={{header|Fortran}}==

{{works with|Fortran|2008}}

use iso_fortran_env, only: real64

implicit none

end function

 

Output for <code>h = 10</code>:

<pre>

100.00000000000000 20.000472391953071

</pre>

 

=={{header|Go}}==

 

import (

fmt.Println()

}

Output, truncated:

<pre>

 

The ''eulerMapping'' closure produces an entire approximating sequence, expressed as a Map object. Here, ''x₀'' and ''y₀'' together are the first point in the sequence, the ODE initial conditions. ''h'' and ''dydx'' are again the step distance and the derivative closure. ''stopCond'' is a closure representing a "stop condition" that causes the the ''eulerMapping'' closure to stop after a finite number of steps; the given default value causes ''eulerMapping'' to stop after 100 steps.

(yn + h * dydx(xn, yn)) as BigDecimal

}

yMap

}

 

 

'''Specific Euler Method Solution for the "Temperature Diffusion" Problem''' (with Newton's derivative formula and constants for environment temperature and object conductivity given)

assert dtdsNewton.maximumNumberOfParameters == 4

 

 

def tEulerH = eulerMapping.rcurry(dtds) { s, t -> s >= 100 }

 

 

'''Newton's Analytic Temperature Diffusion Solution''' (for comparison)

tR + (t0 - tR) * Math.exp(k * (s0 - s))

}

 

def tAnalytic = tNewton.rcurry(0, 100, 20, 0.07)

 

 

'''Specific solutions for 3 step sizes''' (and initial time and temperature)

def tEuler = tEulerH.rcurry(h)

assert tEuler.maximumNumberOfParameters == 2

printf('%5.0f %8.4f %8.4f %9.6f\n', s, tA, tE, relError)

}

 

 

 

=={{header|Haskell}}==

 

 

 

 

 

=={{header|Icon}} and {{header|Unicon}}==

This solution works in both Icon and Unicon. It takes advantage of the <code>proc</code> procedure, which converts a string naming a procedure into a call to that procedure.

 

invocable "newton_cooling" # needed to use the 'proc' procedure

 

euler ("newton_cooling", 100, 0, 100, step_size)

end

 

Sample output:

=={{header|J}}==

'''Solution:'''

euler=: adverb define

'Y0 a b h'=. 4{. y

 

ncl=: _0.07 * -&20 NB. Newton's Cooling Law

'''Example:'''

... NB. output redacted for brevity

ncl euler 100 0 100 5

80 20.0052

90 20.0016

 

=={{header|Java}}==

 

public class Euler {

private static void euler (Callable f, double y0, int a, int b, int h) {

}

}

 

Output for step = 10;

DONE

</pre>

 

=={{header|Lua}}==

TR = 20

k = 0.07

Euler( NewtonCooling, T0, n, delta_t[i] )

end

 

=={{header|Perl}}==

my ($t0, $t1, $k, $step_size) = @_;

my @results = ( [0, $t0] );

$an;

}

Output:<pre>Time 2 err(%) 5 err(%) 10 err(%) Analytic

----------------------------------------------------------------------------

100 20.042 -0.152 20.014 -0.291 20.000 -0.361 20.073</pre>

 

 

=={{header|PicoLisp}}==

 

(de euler (F Y A B H)

(euler newtonCoolingLaw 100.0 0 100.0 2.0)

(euler newtonCoolingLaw 100.0 0 100.0 5.0)

Output:

<pre>...

80.000 20.005

90.000 20.002</pre>

 

=={{header|PureBasic}}==

Prototype.d Func(Time, t)

 

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

<pre>...

85.000 20.053

=={{header|Python}}==

{{trans|Common Lisp}}

t,y = a,y0

print "%6.3f %6.3f" % (t,y)

t += h

 

euler(newtoncooling,100,0,100,10)

Output:

<pre>

80.000 20.005

90.000 20.002

</pre>

 

{{trans|Python}}

 

Output:

10.000 44.000

20.000 27.200

70.000 20.017

80.000 20.005

</pre>

 

=={{header|Scala}}==

 

object App{

 

 

}

 

Output for step = 10;

</pre>

 

 

=={{header|Tcl}}==

{{trans|C++}}

puts "computing $f over \[$a..$b\], step $h"

set y [expr {double($y0)}]

}

puts "done"

Demonstration with the Newton Cooling Law:

expr {-0.07 * ($temp - 20)}

}

euler newtonCoolingLaw 100 0 100 2

euler newtonCoolingLaw 100 0 100 5

End of output:

<pre>

done

</pre>