[boost] [odeint] gsoc 2011: finalization of odeint

Subject: [boost] [odeint] gsoc 2011: finalization of odeint
From: Mario Mulansky (mario.mulansky_at_[hidden])
Date: 2011-03-21 18:13:20

Dear boost community,

I would like to propose a project for the GSoC 2011, namely to improve the  
odeint library currently living in the boost sandbox [1] with the  
(optimistic) goal to put it on a level suitable for a boost review process.

I have been working on this library for about one year now, although I  
couldn't spent much time on it during the last months. The other author of  
odeint is my colleague Karsten. We have had contact to this mailing list  
before [2], getting few, but rather positive feedback.
The odeint library is a modern, template based, generic, C++ library for  
integrating (solving) initial value problems of ordinary differential  
equations. Such an ode is usually given as dx/dt = f(x,t) with x(t=0) =  
x0. x here is generally vector valued, possibly high dimensional. The  
easiest method to solve this problem is the Euler-method, where you  
introduce a small value Dt and then iterate x(t+Dt) = f(x,t)*Dt.  
Obviously, in real applications one uses more sophisticated methods, a  
well known class are the Runge-Kutta methods [3], suitable for many cases.  
Additionally, there exist special methods for system where the time  
evolution has conserved quantities, called symplectic methods. Furthermore  
there are methods for stiff systems and many others.

For odeint, our first focus lies on Runge-Kutta methods. We have  
implemented several such methods together with error control routines and  
lately added dense output functionality. Our very recent code is a generic  
Runge-Kutta stepper that allows the user to build any Runge-Kutta method  
at compile time by providing the appropriate constants and is based on  
fusion::vectors. Karsten wrote a good article on that [4], unfortunately  
in German.
There are also symplectic routines for Hamiltonian systems and we started  
to add implicit methods as well.
We also have unit tests based on the boost test framework and some basic  
documentation.
The library is currently at a level where it can be used in scientific  
applications and it is indeed in use by us and several other people in an  
academic environment.

The major enhancement of our library over existing ones like gsl or  
methods from the numerical recipes is that our routines do not depend on  
the container type used to represent the vector x. So our library works  
with the usual std::vector<double> and array<double,N> but also with  
vector< complex<double> > (already a major improvement over gsl and nr,  
which we get for free, basically) and blitz++ arrays. The major strength  
of this approach, however, is seen when you want to solve odes on complex  
networks where you have to implement your own, non-trivial container type  
representing some kind of network. With odeint you can fully separate the  
network-implementation from the ode-solving algorithm. Furthermore, we are  
able to easily employ the power of CUDA devices to solve odes by the help  
of the thrust library and using thrust::device_vector as our container  
type. It is also possible to use odeint with arbitrary precision types  
like the gmp library.
Some more, unfortunately slightly out-dated, information about odeint can  
be found in [5].

What are my plans for a GSoC?
1. There are still some parts of the library which are not satisfactorily  
designed and need to be rethought. This is where we could really need the  
help of an experienced mentor to create a clean, well structured library.
2. Add methods with varying order (burlisch stoer).
3. Add dense output and error control to the generic runge-kutta  
implementation.
4. Add convenience function that allow users an easier access to the  
libraries capabilities.
5. Create an observer interface that allows the user to analyze properties  
of the system while integrating the equations.
6. Make everything ready for a boos review.

Points 1-5 can surely be realized during the GSoC period, I believe. And  
whatever time is left I will spend on documentation and review preparation.

A few words to myself: I'm currently a PhD student in physics at the  
University of Potsdam working on problems in the field of nonlinear  
dynamics. Solving odes is basically every-day-work for me and I have a  
used many of the routines in odeint for my scientific research.

Thanks for reading. I greatly appreciate any feedback!

Regards,

Mario Mulansky

[1] https://svn.boost.org/svn/boost/sandbox/odeint/
[2]  
http://boost.2283326.n4.nabble.com/library-proposal-odeint-td2670019.html
[3] http://en.wikipedia.org/wiki/Runge%e2%80%93Kutta_methods
[4] http://www.c-plusplus.de/forum/282091
[5] http://www.codeproject.com/KB/recipes/odeint.aspx