Prev

Next

Index-> contents reference index search external

Up-> CppAD library Runge45

CppAD-> Install Introduction AD ADFun multi_thread library cppad_ipopt_nlp Example preprocessor Appendix

library-> ErrorHandler NearEqual speed_test SpeedTest time_test NumericType CheckNumericType SimpleVector CheckSimpleVector nan pow_int Poly LuDetAndSolve RombergOne RombergMul Runge45 Rosen34 OdeErrControl OdeGear OdeGearControl BenderQuad opt_val_hes LuRatio CppAD_vector thread_alloc memory_leak

Runge45-> runge_45_1.cpp runge_45_2.cpp

Headings-> Syntax Purpose Include xf Fun ---..t ---..x ---..f ---..Warning M ti tf xi e Scalar Vector Parallel Mode Example Source Code

An Embedded 4th and 5th Order Runge-Kutta ODE Solver
Syntax
# include <cppad/runge_45.hpp>
xf = Runge45(F, M, ti, tf, xi)
xf = Runge45(F, M, ti, tf, xi, e)

Purpose
This is an implementation of the Cash-Karp embedded 4th and 5th order Runge-Kutta ODE solver described in Section 16.2 of Numerical Recipes . We use $\mathit{n}$ for the size of the vector xi. Let $\mathbf{R}$ denote the real numbers and let $\mathit{F}:\mathbf{R}\times {\mathbf{R}}^{\mathit{n}}\to {\mathbf{R}}^{\mathit{n}}$ be a smooth function. The return value xf contains a 5th order approximation for the value $\mathit{X}(\mathit{tf})$ where $\mathit{X}:[\mathit{ti},\mathit{tf}]\to {\mathbf{R}}^{\mathit{n}}$ is defined by the following initial value problem: $$\begin{array}{ccc}\hfill \mathit{X}(\mathit{ti})& \hfill =\hfill & \mathit{xi}\hfill \\ \hfill \mathit{X}\text{'}(\mathit{t})& \hfill =\hfill & \mathit{F}[\mathit{t},\mathit{X}(\mathit{t})]\hfill \end{array}$$ If your set of ordinary differential equations are stiff, an implicit method may be better (perhaps Rosen34 .)

Include
The file cppad/runge_45.hpp is included by cppad/cppad.hpp but it can also be included separately with out the rest of the CppAD routines.

xf
The return value xf has the prototype
     Vector xf
and the size of xf is equal to n (see description of Vector below). $$\mathit{X}(\mathit{tf})=\mathit{xf}+\mathit{O}({\mathit{h}}^6)$$ where $\mathit{h}=(\mathit{tf}-\mathit{ti})/\mathit{M}$ is the step size. If xf contains not a number nan , see the discussion for f .

Fun
The class Fun and the object F satisfy the prototype
     Fun &F
The object F (and the class Fun) must have a member function named Ode that supports the syntax
     F.Ode(t, x, f)

t
The argument t to F.Ode has prototype
     const Scalar &t
(see description of Scalar below).

x
The argument x to F.Ode has prototype
     const Vector &x
and has size n (see description of Vector below).

f
The argument f to F.Ode has prototype
     Vector &f
On input and output, f is a vector of size n and the input values of the elements of f do not matter. On output, f is set equal to $\mathit{F}(\mathit{t},\mathit{x})$ in the differential equation. If any of the elements of f have the value not a number nan the routine Runge45 returns with all the elements of xf and e equal to nan.

Warning
The argument f to F.Ode must have a call by reference in its prototype; i.e., do not forget the & in the prototype for f.

M
The argument M has prototype
     size_t M
It specifies the number of steps to use when solving the differential equation. This must be greater than or equal one. The step size is given by $\mathit{h}=(\mathit{tf}-\mathit{ti})/\mathit{M}$ , thus the larger M, the more accurate the return value xf is as an approximation for $\mathit{X}(\mathit{tf})$ .

ti
The argument ti has prototype
     const Scalar &ti
(see description of Scalar below). It specifies the initial time for t in the differential equation; i.e., the time corresponding to the value xi.

tf
The argument tf has prototype
     const Scalar &tf
It specifies the final time for t in the differential equation; i.e., the time corresponding to the value xf.

xi
The argument xi has the prototype
     const Vector &xi
and the size of xi is equal to n. It specifies the value of $\mathit{X}(\mathit{ti})$

e
The argument e is optional and has the prototype
     Vector &e
If e is present, the size of e must be equal to n. The input value of the elements of e does not matter. On output it contains an element by element estimated bound for the absolute value of the error in xf $$\mathit{e}=\mathit{O}({\mathit{h}}^5)$$ where $\mathit{h}=(\mathit{tf}-\mathit{ti})/\mathit{M}$ is the step size. If on output, e contains not a number nan, see the discussion for f .

Scalar
The type Scalar must satisfy the conditions for a NumericType type. The routine CheckNumericType will generate an error message if this is not the case. In addition, the following operations must be defined for Scalar objects a and b:

Operation	Description
a < b	less than operator (returns a bool object)

Vector
The type Vector must be a SimpleVector class with elements of type Scalar . The routine CheckSimpleVector will generate an error message if this is not the case.

Parallel Mode
For each set of types Scalar , Vector , and Fun , the first call to Runge45 must not be parallel execution mode.

Example
The file runge_45_1.cpp contains a simple example and test of Runge45. It returns true if it succeeds and false otherwise.

The file runge_45_2.cpp contains an example using Runge45 in the context of algorithmic differentiation. It also returns true if it succeeds and false otherwise.

Source Code
The source code for this routine is in the file cppad/runge_45.hpp.

---

Input File: cppad/runge_45.hpp