the taylor series method for ordinary differential · pdf filethe taylor series method for...
TRANSCRIPT
The Taylor series method for ordinarydifferential equations
Karsten Ahnert1,2
Mario Mulansky2
1 Ambrosys GmbH, Potsdam2 Institut für Physik und Astronomie, Universität Potsdam
December, 8, 2011
ambrosys
1
Outline
1 Solving ODEs
2 The method
3 Implementation
4 Conclusion
2
Solving Ordinary differential equations numerically
Find a numerical solution of the initial value problem for an ODE
x = f (x , t) , x(t = 0) = x0
Example: Explicit Euler
x(t + ∆t) = x(t) + ∆t f (x(t), t) +O(∆t2)
General scheme of order s
x(t) 7→ x(t + ∆t) , or
x(t + ∆t) = Ftx(t) +O(∆ts+1)
3
Numerical methods – Overview
Methods:Steppers: x(t) 7→ x(t + ∆t)Methods with embedded error estimationAdaptive step size controlDense output
Examples:Explicit Runge Kutta methodsImplicit methods for stiff systemsSymplectic methods for Hamiltonian systemsMultistep methodsTaylor series method
4
Software for ordinary differential equations
GNU Scientific library – gsl, CNumerical recipes, C and C++www.odeint.com, C++odeint, Pythonapache.common.math, Java
5
Taylor series method
x = f (x)
Taylor series of the solution
x(t + ∆t) = x(t) + ∆t x(t) +∆t2
2!x(t) +
∆t3
3!x (3)(t) + . . .
Auto Differentiation to calculate x(t), x(t), x (3)(t), . . .Applications: Problems with high accuracy
astrophyical application, chaotic dynamical systemsArbitrary precision typesInterval arithmetics
6
Software for the Taylor method
Most software packages use generatorsATSMCC, ATOMFT – Fortran generatorGeorge F. Corliss and Y. F. Chang. ACM Trans. Math. Software, 8(2):114-144, 1982.
Y. F. Chang and George F. Corliss, Comput. Math. Appl., 28:209-233, 1994
Taylor – C GeneratorÁngel Jorba and Maorong Zou, Experiment. Math. Volume 14, Issue 1 (2005), 99-117.
TIDES – arbitrary precision, Mathematica generatorRodríguez, M. et. al, TIDES: A free software based on the Taylor series method, 2011
Operator overloadingAdol-CcppAD
Expression templatesTaylor
7
1 Solving ODEs
2 The method
3 Implementation
4 Conclusion
8
Notation
Taylor series of the ODE
x(t + ∆t) = x(t) + ∆t x(t) +∆t2
2!x(t) +
∆t3
3!x (3)(t) + . . .
Introduce the reduced derivatives Xi
Fi =1i!
(f(x(t)
))(i), Xi =
1i!
x (i)(t) , Xi+1 =1
i + 1Fi
Taylor series
x(t + ∆t) = X0 + ∆tX1 + ∆t2X2 + ∆t3X3 + . . .
9
Algebraic operations – Expression trees
Example: Lorenz system
x = σ(y − x) y = Rx − y − xz z = −bz + xy
Expression trees
σ
xy
R x
x zy x yzR
10
The algorithm – Evaluation of the expression tree
Recursive determination of the Taylor coefficients1. Initialize X0 = x(t)2. Calculate X1 = F0(X0)
3. Calculate X2 = 12F1(X0,X1)
4. Calculate X3 = 13F2(X0,X1,X2)
. . .Calculate Xs = 1
s Fs−1(X0,X1, . . . ,Xs−1)
Finally x(t + ∆t) = X0 + ∆tX1 + ∆t2X2 + . . .
In every iteration the expression tree is evaluated!
11
The algorithm – Evaluation of the expression tree
Recursive determination of the Taylor coefficients1. Initialize X0 = x(t)2. Calculate X1 = F0(X0)
3. Calculate X2 = 12F1(X0,X1)
4. Calculate X3 = 13F2(X0,X1,X2)
. . .Calculate Xs = 1
s Fs−1(X0,X1, . . . ,Xs−1)
Finally x(t + ∆t) = X0 + ∆tX1 + ∆t2X2 + . . .
In every iteration the expression tree is evaluated!
11
Algebraic operations
At every iteration the nodes in the expression tree have to beevaluated
Formulas for iteration i :
Constants: Ci = cδi,0
Dependend variable x : Xi
Summation s = l + r : Si = Li + Ri
Multiplication m = l × r : Mi =i∑
j=0LjRi−j
Division d = l/r : Di = 1/R0(Li −i−1∑j=0
DjRi−j)
Formulas for special functions exist: exp, log, cos, sin, . . .
12
Algebraic operations – Formulas
At every iteration the nodes in the expression tree have to beevaluated. Formulas for iteration i :
CConstants: Ci = cδi,0
xDependend variable: x Xi
Summation s = l + r : Si = Li + Ri
Multiplication m = l × r : Mi =i∑
j=0LjRi−j
Division d = l/r : Di = 1/R0(Li −i−1∑j=0
DjRi−j )
f(x)
Formulas for specialfunctions exist
13
Nice side effects
Step size controlError estimate: err = Xs
v = || errkεrel+εabs|xk | ||
∆t = v−1/s
No acceptance or rejection step is required
Dense output is trivially presentx(t + τ) = X0 + τX1 + τ2X2 + τ3X3 + . . . , 0 < τ < ∆t
Methods for order estimation exist
14
1 Solving ODEs
2 The method
3 Implementation
4 Conclusion
15
Implementation
Taylor
Downloadhttps://github.com/headmyshoulder/taylor
Taylor will be integrated into odeint
Implements some odeint - stepper
Modern C++Heavy use of the C++ template systemsExpression templates for expression treesTemplate meta-programming
16
Implementation
Taylor
Downloadhttps://github.com/headmyshoulder/taylor
Taylor will be integrated into odeint
Implements some odeint - stepper
Modern C++Heavy use of the C++ template systemsExpression templates for expression treesTemplate meta-programming
16
Implementation
Taylor
Downloadhttps://github.com/headmyshoulder/taylor
Taylor will be integrated into odeint
Implements some odeint - stepper
Modern C++Heavy use of the C++ template systemsExpression templates for expression treesTemplate meta-programming
16
C++ Templates
Here, C++ templates will be used to create the expressiontree – Expression TemplatesTemplate Metaprogramming to evaluate the expressiontemplatesIt basically means using the template engine to generate aprogram from which the compiler creates then the binaryC++ compilers always use the template engine (noadditional compile step required)
Template engine and templates are a functionalprogramming languageTemplates form a Turing-complete programming language−→ You can solve any problem with the template engine
17
C++ Templates
Here, C++ templates will be used to create the expressiontree – Expression TemplatesTemplate Metaprogramming to evaluate the expressiontemplatesIt basically means using the template engine to generate aprogram from which the compiler creates then the binaryC++ compilers always use the template engine (noadditional compile step required)
Template engine and templates are a functionalprogramming languageTemplates form a Turing-complete programming language−→ You can solve any problem with the template engine
17
Expression templates
template< class L , class R > struct binary_expression{
binary_expression( string name , L l , R r )...L m_l;R m_r;
};
struct terminal_expression{
terminal_expression( string name ) ...};
const terminal_expression arg1( "arg1" ) , arg2( "arg2" );
template< class L , class R >binary_expression< L , R > operator+( L l , R r ){
return binary_expression< L , R >( "Plus" , l , r );}...
template< class Expr > void print( Expr expr ) { ... }
print( arg1 );print( arg1 + ( arg2 + arg1 - arg2 ) );
18
Expression templates
Expression template are constructed during compile-timeStrong optimization – no performance lossLazynessApplications: Linear algebra systems, AD, (E)DSL
Example MTL4mtl4::dense_matrix< double > m1( n , n ) , m2( n , n ) , m3( n , n ) ;
/ / do s o m e t h i n g u s e f u l w i t h m1 , m2 , m3
mtl4::dense_matrix< double > result = m1 + 5.0 * m2 + 0.5 * m3 ;
Last line creates an expression template which is evaluated tofor( int i=0 ; i<n ; ++i )
for( int j=0 ; j<n ; ++j )result( i , j ) = m1( i , j ) + 5.0 * m2( i , j ) + 0.5 * m3( i , j );
19
First example – Lorenz system
taylor_direct_fixed_order< 25 , 3 > stepper;state_type x = {{ 10.0 , 10.0 , 10.0 }} ;double t = 0.0;double dt = 1.0;while( t < 50000.0 ){
stepper.try_step(fusion::make_vector(
sigma * ( arg2 - arg1 ) ,R * arg1 - arg2 - arg1 * arg3 ,arg1 * arg2 - b * arg3) , x , t , dt );
cout << t << "\t" << x << "\t" << dt << endl;}
ODE is a compile time sequence of expression templatesThe expression template is defined with boost::proto
No preprocessing step is necessary!
20
Expression templates and ODEs
Boost.Proto (C++ library)Creation, manipulation and evaluation of the syntax treeGrammar = Allowed expression + (optional) Transformation
Taylor library uses Proto as front end:The ODE is a set of Proto expression templatesODE is transformed into a custom expression template
struct tree_generator :proto::or_<
variable_generator< proto::_ > ,constant_generator ,plus_generator< tree_generator > ,minus_generator< tree_generator > ,multiplies_generator< tree_generator > ,divides_generator< tree_generator > ,unary_generator< tree_generator >
> { };
21
Expression templates and ODEs
Boost.Proto (C++ library)Creation, manipulation and evaluation of the syntax treeGrammar = Allowed expression + (optional) Transformation
Taylor library uses Proto as front end:The ODE is a set of Proto expression templatesODE is transformed into a custom expression template
struct tree_generator :proto::or_<
variable_generator< proto::_ > ,constant_generator ,plus_generator< tree_generator > ,minus_generator< tree_generator > ,multiplies_generator< tree_generator > ,divides_generator< tree_generator > ,unary_generator< tree_generator >
> { };
21
Expression templates and ODEs
Evaluation of the custom template – iteration several timesof the templateThe nodes implement the rules for the algebraicexpressionsOptimzation of the expression tree
R
R ×
Example: The plus nodetemplate< class Left , class Right >struct plus_node : binary_node< Left , Right >{
plus_node( const Left &left , const Right &right ): binary_node< Left , Right >( left , right ) { }
template< class State , class Derivs >Value operator()( const State &x , const Derivs &derivs , size_t which ){
return m_left( x , derivs , which ) + m_right( x , derivs , which );}
};
22
The interface
Interface for easy implementation of arbitrary ODEs existtaylor_direct_fixed_order< 25 , 3 > stepper;stepper.try_step( sys , x , t , dt );
sys represents the ODE, Example:fusion::make_vector(
sigma * ( arg2 - arg1 ) ,R * arg1 - arg2 - arg1 * arg3 ,arg1 * arg2 - b * arg3 )
x is the state of the ODE is in-place transformed
t,dt are the time and the step size
23
Results
Performance comparison against full Fortran code
The Lorenz system as test systemBenchmarking: a Fortran code with a non-ADimplementationBoth codes have the same performance, run-timedeviation is less 20%Exact result depends strongly on the used compiler (gcc4.5, gcc 4.6, gfortran, ...)
24
Comparison against other mehtods
10-12
10-9
10-6
10-3
ε rel
10-2
10-1
100
101
102
t Co
mp
Runge Kutta Cash Karp 54
Taylor s=15
Taylor s=25
Taylor has good performance for high precisionOutperforms the classical Runge-Kutta steppers
25
Conclusion
Taylor – A C++ library for the Taylor series method ofordinary differential equationsUses expression templates as basis for the automaticdifferentiationFastUses modern C++ methodsTemplate Metaprogramming is the main programmingtechnique
26
Outlook
The library is not completeImplementation of special functionsImplementation of stencils for lattice equationsImplementation of variable orderImplementation of dense output functionalityPortability layer for arbitrary precision typesIntegration into odeint
27
Resources
Download and developmenthttps://www.github.com/headmyshoulder/taylor
Odeintodeint.com
Contributions and feedbackare highly welcome
28