Integrators for time stepping - Revision history

AndrejKP: Typo fixes

2022-06-16T12:45:03Z

Typo fixes

Gkosec: /* Explicit (single step) methods */

2017-11-29T06:06:51Z

‎Explicit (single step) methods

Gkosec: /* Explicit (single step) methods */

2017-11-29T06:05:34Z

‎Explicit (single step) methods

Ipribec: /* Usage */

2017-11-13T22:02:26Z

‎Usage

Ipribec at 19:05, 13 November 2017

2017-11-13T19:05:44Z

Ipribec: Added Lorenz Attractor Example.

2017-11-13T19:05:06Z

Added Lorenz Attractor Example.

Jureslak: /* Adaptive methods */

2017-11-10T11:48:37Z

‎Adaptive methods

Jureslak: /* Adaptive methods */

2017-11-10T11:46:54Z

‎Adaptive methods

Jureslak: /* Explicit (single step) methods */

2017-11-10T11:46:27Z

‎Explicit (single step) methods

Jureslak: /* Explicit multistep methods */

2017-11-10T11:45:47Z

‎Explicit multistep methods

@@ Line 13: / Line 13: @@
 where $y$ is the unknown (possibly vector) function, $t_0$ is the start time, $f$ is the derivative (the functions we wish to integrate) and $y_0$ is the initial value of $y$.
-Numerically, we usually choose a time step $\Delta t$ and integrate the function up to a certain time $t_{\max}$. Times os subsequent time steps are denoted with $t_i$ and function values with $y_i$.
+Numerically, we usually choose a time step $\Delta t$ and integrate the function up to a certain time $t_{\max}$. Times of subsequent time steps are denoted with $t_i$ and function values with $y_i$.
 The simplest method is explicit Euler's method:
@@ Line 20: / Line 20: @@
 == Explicit (single step) methods ==
-A family of single step methods are exaplicit Runge-Kutta methods, which uses intermediate derivative values to give a better estimation of value $y_{n+1}$ on the next step.
+A family of single step methods are explicit Runge-Kutta methods, which use intermediate derivative values to give a better estimation of value $y_{n+1}$ on the next step.
 It is given by
@@ Line 46: / Line 46: @@
+$
-First order method is the Euler's method above, while methods of very high error are available.
+First order method is the Euler's method above, while methods of very high order are available.
 The most famous is RK4, the Runge Kutta method of fourth order.
@@ Line 79: / Line 79: @@
 $e_{n+1} = y_{n+1} - y^*_{n+1} = h\sum_{i=1}^s (\beta_i - \beta^*_i) k_i$.
-If $\|e_{n+1}\| < \varepsilon$, time step can be increased, otherwise it is decreased. This cn be achieved by scaling $\Delta t$ in accorance with $\varepsilon / \|e_{n+1}\|$.
+If $\|e_{n+1}\| < \varepsilon$, time step can be increased, otherwise it is decreased. This can be achieved by scaling $\Delta t$ in accorance with $\varepsilon / \|e_{n+1}\|$.
 These methods are implemented in Matlab as ode45 and similar. They can be found [https://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods#Embedded_methods here], with a sample Matlab implementation of Cash-Karp method [https://github.com/jureslak/numerika-fmf/blob/master/ninde/hw2/CashKarp.m here].

@@ Line 48: / Line 48: @@
 First order method is the Euler's method above, while methods of very high error are available.
 The most famous is RK4, the Runge Kutta method of fourth order.
-−
    & {{k}_{1}}=f({{t}_{i}},{{y}_{i}}) \\
   & {{k}_{2}}=f({{t}_{i}}+\Delta t/2,{{y}_{i}}+\Delta t{{k}_{1}}/2) \\
@@ Line 54: / Line 55: @@
   & {{k}_{4}}=f({{t}_{i}}+\Delta t,{{y}_{i}}+\Delta t{{k}_{3}}) \\
   & {{y}_{i+1}}={{y}_{i}}+\Delta t/6({{k}_{1}}+2{{k}_{2}}+2{{k}_{3}}+{{k}_{4}}). \\
+\end{align*}$

@@ Line 47: / Line 47: @@
 First order method is the Euler's method above, while methods of very high error are available.
-The most famous is RK4, the Runge Kutta method of fourth order. A more complete list can be found [https://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods here].
+The most famous is RK4, the Runge Kutta method of fourth order.
 Most common methods are implemented in the [http://www-e6.ijs.si/ParallelAndDistributedSystems/MeshlessMachine/technical_docs/html/namespacemm_1_1integrators_1_1Explicit.html Explicit] namespace.

← Older revision		Revision as of 22:02, 13 November 2017
Line 159:		Line 159:
	</syntaxhighlight>		</syntaxhighlight>

−	[[File:lorenz.png\|500px]]	+	<figure id="fig:lorenz_system">
		+	[[File:lorenz.png\|500px\|thumb\|upright=2\|center\|<caption>A sample solution of the Lorenz system for the values $\sigma=10$, $\rho=28$ and $\beta = 8/3$. The two trajectories (one in orange, the other in blue) correspond to two initial points that differ by a small amount in the $z$-coordinate.</caption>]]
		+	</figure>

@@ Line 131: / Line 131: @@
-[https://en.wikipedia.org/wiki/Lorenz_system Lorenz Attractor]:
+[https://en.wikipedia.org/wiki/Lorenz_system Lorenz system:]
 <syntaxhighlight lang="c++">
@@ Line 140: / Line 140: @@
 double beta = 8./3.;
 auto dy_dt = [&](double, const Vec3d& y) {
      Vec3d der(3);

← Older revision		Revision as of 19:05, 13 November 2017
Line 129:		Line 129:
	}		}
	</syntaxhighlight>		</syntaxhighlight>
		+
		+
		+	[https://en.wikipedia.org/wiki/Lorenz_system Lorenz Attractor]:
		+
		+	<syntaxhighlight lang="c++">
		+
		+	// System parameters
		+	double sigma = 10.;
		+	double rho = 28.;
		+	double beta = 8./3.;
		+
		+	// The Lorenz System
		+	auto dy_dt = [&](double, const Vec3d& y) {
		+	Vec3d der(3);
		+	der(0) = sigma*(y(1)-y(0));
		+	der(1) = y(0)*(rho-y(2))-y(1);
		+	der(2) = y(0)y(1)-betay(2);
		+	return der;
		+	};
		+
		+	double dt = 0.001; // Timestep
		+	Vec3d y0 = {1, 1, 1}; // Initial condition
		+
		+	auto integrator = integrators::Explicit::RK4().solve(dy_dt, 0, 100, dt, y0);
		+	for (auto& step : integrator) {
		+	auto t = step.time();
		+	auto y = step.value();
		+	// output values
		+	}
		+	</syntaxhighlight>
		+
		+	[[File:lorenz.png\|500px]]

← Older revision		Revision as of 11:48, 10 November 2017
Line 71:		Line 71:

	These methods are implemented in Matlab as ode45 and similar. They can be found [https://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods#Embedded_methods here], with a sample Matlab implementation of Cash-Karp method [https://github.com/jureslak/numerika-fmf/blob/master/ninde/hw2/CashKarp.m here].		These methods are implemented in Matlab as ode45 and similar. They can be found [https://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods#Embedded_methods here], with a sample Matlab implementation of Cash-Karp method [https://github.com/jureslak/numerika-fmf/blob/master/ninde/hw2/CashKarp.m here].
		+
		+	These methods are not implemented yet, but will probably be added in the future.

	== Usage ==		== Usage ==

@@ Line 64: / Line 64: @@
 Usually the have some addition parameters, such as $\Delta t_{\max}$ and $\Delta t_{\min}$ representing maximal and minimal allowed time steps and $\varepsilon$, represeting tolrance.
-A family of adaptive methods can be derived from Runge Kutta methods above. Using a method of order $k$ and $k+1$, that differ only in weights, called $\beta$ and $\beta^\ast$, error can be estimated using [Richardson Extrapolation https://en.wikipedia.org/wiki/Richardson_extrapolation]:
+A family of adaptive methods can be derived from Runge Kutta methods above. Using a method of order $k$ and $k+1$, that differ only in weights, called $\beta$ and $\beta^\ast$, error can be estimated using [https://en.wikipedia.org/wiki/Richardson_extrapolation Richardson Extrapolation]:
 $e_{n+1} = y_{n+1} - y^*_{n+1} = h\sum_{i=1}^s (\beta_i - \beta^*_i) k_i$.
@@ Line 71: / Line 71: @@
 These methods are implemented in Matlab as ode45 and similar. They can be found [https://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods#Embedded_methods here], with a sample Matlab implementation of Cash-Karp method [https://github.com/jureslak/numerika-fmf/blob/master/ninde/hw2/CashKarp.m here].
 == Usage ==

← Older revision		Revision as of 11:45, 10 November 2017
Line 55:		Line 55:

	The drawbacks of these mehtods are that another method of same order is needed to compute the initial time steps and that they can not be easily modified to work with adaptive time steps.		The drawbacks of these mehtods are that another method of same order is needed to compute the initial time steps and that they can not be easily modified to work with adaptive time steps.
		+
		+	Most common methods are implemented in [http://www-e6.ijs.si/ParallelAndDistributedSystems/MeshlessMachine/technical_docs/html/namespacemm_1_1integrators_1_1ExplicitMultistep.html ExplicitMultistep] namespace.

	== Adaptive methods ==		== Adaptive methods ==