odeint/TODO

* REFACTORING AND CLEANUP
  * check if everywhere static_cast< value_type > is used
  * check if rational number are expressed as a / b with a and b integers!, neccessary fpr gmpxx
  * bessere Namen für dense_output_controlled_explicit_fsal
  OK * check header guards
  OK * check copyright note
  OK * describe every file in the preamble
  OK * check spacings, not tabs

  
* INTEGRATE FUNCTIONS
  * dense_output_stepper : call with reset
  OK * dopri5 in integrate_const does not work - FIXED
  OK * define EXACTLY what integrate_const and integrate_adaptive for every stepper means, documentate
    * integrate_adaptive() : start_time , end_time
      * start_time , t1 , t2 , ... , t_n-1 , end_time ?
      * OR start_time , t1 , t2 , ... , t_n-1 , t_n, where t_n-1 < end_time and t_n > end_time
    DONE


* THRUST
  OK * test with controlled steppers (lorenz bifurcations test)
    * it works, but it does not make sense  
  OK * test with dense output steppers (ensemble test)
    OK * it works, compare performance between rk4 and dopri5
  OK * test with units
    * thrust will not support units
  OK * introduce get_value in thrust::operations::rel_error und thrust::operations::max for boost::units
    * no, we will not do this
  * check copy implementation in thrust::resize()


* DOCUMENTATION
  OK * Tutorials
  * Concepts
  * HOWTO extend odeint
  OK * use gh-pages, remove html from the source control
  * doxygen generated reference


* RECHERCHE
  * Hoisting
  * C++0x
  * Factory functions, does the make sense
  * Steppers with state, like FSAL steppers, dense output and multi-step methods
    * maybe one initialize( system , x0 , t0 , dt0 )
  * Generalize and unify controlled steppers, for example rosenbrock controller should be more general
  * Generalize and unify dense output stepper, for example dense output rosenbrock
  * same system function interface for implicit_euler and rosenbrock4

* UNIT TEST
  NEARLY DONE * test operations
  * test vector_space_algebra, maybe with some proto lib
  NEARLY DONE * test copying
    * include controlled_error_stepper_fsal
    * include dense_output_explicit
    * inlcude dense_output_controlled_explicit_fsal
  * test gsl
  * test explicit stepper with ranges
  * split check_concepts into check_stepper_concept, check_error_stepper_concept, check_controlled_stepper_concept
  * include test/thrust in jam system, use system from
  * ranges and the integrate functions
  * symplectic intergrators and ranges
  * adams_moulton complete
  * adams_bashforth_moulton complete
  * check once more, if all contructor, destructors and assign-operators are present

* UNIT TEST Requirements (NEW):
  * test stepper concepts
    * top level concepts (stepper, error_stepper, controlled_stepper, dense_output_stepper)
    * adjust_size, algebras, various versions of do_step, try_step, ... 
  * test resizing and resize functionality
  * test copying (copy ctor, assign operator)
  * stepper results ?
  * stepper with ranges
  * stepper with units
 

TO BE DISCUSSED:

* Concept Jungle - describe problem, find solution (algebra, do_steps)
* boost range enhancement: copy, construct, descruct, resize, adjust_size ...
* boost::ref for system functions
* algebras as Proto expression and as instances



DONE:

OK * INTEGRATE FUNCTIONS
  OK * check forwarding problem, ranges
  OK * check where exactly the observer will be called (before, after each step?)
  OK * functions without obversers
  OK * integrate without stepper , intelligent choice of the stepper
  OK * check function signatures
  OK * what to throw?
  OK * check lambdas, lambda is broken
OK * move error_checker into controlled_stepper
OK * finishing change of controlled_stepper to units
OK * dense output for rosenbrock
OK * symplecit_stepper
  OK * find an appropriate name, (symplectic stroemer nystroem)
  OK * check is the coefficients are named good
  OK * include do_step( system , q , p , t , dt )
OK * rename error_checker_standard to default_error_checker
OK * check the order of arguments in the observer in integrate functions and initialize in dense_output_stepper
OK * decrease complexity:
  LATER * remove construct, destruct, copy ?
  OK * remove the overloads solving the forwarding problem. boost::range can not be used then anymore
OK * file cleanup
   OK * split resizing and copy/destruct/construct in different files
   OK * subfolder algebra, operations, util
OK * change standard_operations::rel_error in order to word with units and test it
OK * include implicit euler
  OK * call via std::pair< deriv , jacobi >
  OK * resizing
OK * operations that fit units
OK * operations that fit result_of
OK * change stepper to stepper_units
OK * change error_stepper to error_stepper_units
OK * change dense_output to units
  OK * roll out dense_output_explicit_euler::calc_state() to explicit_euler::dense_output()
  OK * roll out dense_output_dopri5::calc_state() to explicit_error_dopri5::dense_output()
  OK * create dense_output_explicit
  OK * create dense_output_explicit_controlled_fsal
OK * change resizing concept, in order to word within the implicit steppers
OK * in all tests and regression test do not include odeint.hpp, only include the headers which are really needed
OK * start new doc or cleanup the old project
OK * unit test
  OK * test standard_algebra
  OK * test fusion_algebra
  OK * test, if copy construct of stepper_base is called when explicit_euler is used
  OK * test units with dense output
OK * include rosenbrock4 in trunk
* ranges:
  OK * test ranges in symplectic_rkn_stepper
  OK * dense_output
  OK * explicit_stepper_and_error_stepper_fsal_base
  OK * controlled_error_stepper
  OK * check comments (spelling and if the comment is true, in some versions dxdt is already const) 
  OK * check names of the impl functions