adding associated types to the concept documentation

2025-05-09 23:24:01 +00:00 · 2012-06-19 09:35:08 +02:00 · 2012-06-19 09:35:08 +02:00 · ef46c16443
commit ef46c16443
parent 76f170d047
6 changed files with 100 additions and 31 deletions
--- a/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
+++ b/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
@ -149,7 +149,6 @@ public:
    typedef typename stepper_type::value_type value_type;
    typedef typename stepper_type::deriv_type deriv_type;
    typedef typename stepper_type::time_type time_type;
-    typedef typename stepper_type::order_type order_type;
    typedef typename stepper_type::algebra_type algebra_type;
    typedef typename stepper_type::operations_type operations_type;
    typedef Resizer resizer_type;
@ -375,7 +374,6 @@ public:
    typedef typename stepper_type::value_type value_type;
    typedef typename stepper_type::deriv_type deriv_type;
    typedef typename stepper_type::time_type time_type;
-    typedef typename stepper_type::order_type order_type;
    typedef typename stepper_type::algebra_type algebra_type;
    typedef typename stepper_type::operations_type operations_type;
    typedef Resizer resizer_type;
--- a/doc/index.html
+++ b/doc/index.html
@ -94,7 +94,7 @@
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: June 12, 2012 at 06:11:45 GMT</small></p></td>
+<td align="left"><p><small>Last revised: June 19, 2012 at 06:34:08 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
--- a/libs/numeric/odeint/doc/concepts/controlled_stepper.qbk
+++ b/libs/numeric/odeint/doc/concepts/controlled_stepper.qbk
@ -7,6 +7,27 @@ This concept specifies the interface a controlled stepper has to fulfill to be u
 A controlled stepper following this Controlled Stepper concept provides the possibility to perform one step of the solution /x(t)/ of an ODE with step-size /dt/ to obtain /x(t+dt)/ with a given step-size /dt/.
 Depending on an error estimate of the solution the step might be rejected and a smaller step-size is suggested.

+[heading Associated types]
+
+*  '''<para>'''[*state_type]'''</para>'''
+'''<para>'''`Stepper::state_type`'''</para>'''
+'''<para>'''The type characterizing the state of the ODE, hence ['x].'''</para>'''
+
+*  '''<para>'''[*deriv_type]'''</para>'''
+'''<para>'''`Stepper::deriv_type`'''</para>'''
+'''<para>'''The type characterizing the derivative of the ODE, hence ['d x/dt].'''</para>'''
+
+*  '''<para>'''[*time_type]'''</para>'''
+'''<para>'''`Stepper::time_type`'''</para>'''
+'''<para>'''The type characterizing the dependent variable of the ODE, hence the time ['t].'''</para>'''
+
+*  '''<para>'''[*value_type]'''</para>'''
+'''<para>'''`Stepper::value_type`'''</para>'''
+'''<para>'''The numerical data type which is used within the stepper, something like `float`, `double`, `complex&lt; double &gt;`.'''</para>'''
+
+
+
+
 [heading Notation]

 [variablelist 
@ -23,16 +44,16 @@ Depending on an error estimate of the solution the step might be rejected and a

 [table
  [[Name] [Expression] [Type] [Semantics]]
-  [[Do step] [`stepper.try_step( sys , x , t , dt )`] [`controlled_step_result`] [Tries one step of step size `dt`. If the step was successful, `success` is returned, the resulting state is written to `x`, the new time is stored in `t` and `dt` now contains a new (possibly larger) step-size for the next step. If the error was too big, `rejected` is returned and the results are neglected - `x` and `t` are unchanged and `dt` now contains a reduced step-size to be used for the next try.] ]
-  [[Do step with reference] [`stepper.try_step( boost::ref(sys) , x , t , dt )`] [`void`] [Same as above with `System` as reference] ]
+  [[Do step] [``stepper.try_step( sys , x , t , dt )``] [`controlled_step_result`] [Tries one step of step size `dt`. If the step was successful, `success` is returned, the resulting state is written to `x`, the new time is stored in `t` and `dt` now contains a new (possibly larger) step-size for the next step. If the error was too big, `rejected` is returned and the results are neglected - `x` and `t` are unchanged and `dt` now contains a reduced step-size to be used for the next try.] ]
+  [/ [Do step with reference] [`stepper.try_step( boost::ref(sys) , x , t , dt )`] [`void`] [Same as above with `System` as reference] ]
 ]

 [heading Models]

-* controlled_error_stepper< runge_kutta_cash_karp54 >
-* controlled_error_stepper_fsal< runge_kutta_dopri5 >
-* controlled_error_stepper< runge_kutta_fehlberg78 >
-* rosenbrock4_controller
-* bulirsch_stoer
+* `controlled_error_stepper< runge_kutta_cash_karp54 >`
+* `controlled_error_stepper_fsal< runge_kutta_dopri5 >`
+* `controlled_error_stepper< runge_kutta_fehlberg78 >`
+* `rosenbrock4_controller`
+* `bulirsch_stoer`

 [endsect]
--- a/libs/numeric/odeint/doc/concepts/dense_output_stepper.qbk
+++ b/libs/numeric/odeint/doc/concepts/dense_output_stepper.qbk
@ -8,10 +8,23 @@ The step-size `dt` might be adjusted automatically due to error control.
 Dense output steppers also can interpolate the solution to calculate the state /x(t')/ at any point /t <= t' <= t+dt/.

 [heading Associated types]
-[variablelist 
-  [[`Stepper::state_type`] [A type representing the state /x/ of the system]]
-  [[`Stepper::time_type`] [A type representing the time /t/ of the system]]
-]
+
+*  '''<para>'''[*state_type]'''</para>'''
+'''<para>'''`Stepper::state_type`'''</para>'''
+'''<para>'''The type characterizing the state of the ODE, hence ['x].'''</para>'''
+
+*  '''<para>'''[*deriv_type]'''</para>'''
+'''<para>'''`Stepper::deriv_type`'''</para>'''
+'''<para>'''The type characterizing the derivative of the ODE, hence ['d x/dt].'''</para>'''
+
+*  '''<para>'''[*time_type]'''</para>'''
+'''<para>'''`Stepper::time_type`'''</para>'''
+'''<para>'''The type characterizing the dependent variable of the ODE, hence the time ['t].'''</para>'''
+
+*  '''<para>'''[*value_type]'''</para>'''
+'''<para>'''`Stepper::value_type`'''</para>'''
+'''<para>'''The numerical data type which is used within the stepper, something like `float`, `double`, `complex&lt; double &gt;`.'''</para>'''
+

 [heading Notation]

@ -28,17 +41,24 @@ Dense output steppers also can interpolate the solution to calculate the state /

 [table
  [[Name] [Expression] [Type] [Semantics]]
+
  [[Initialize integration] [`stepper.initialize( x0 , t0 , dt0 )`] [void] [Initializes the stepper with initial values `x0`, `t0` and `dt0`.]]
+
  [[Do step] [`stepper.do_step( sys )`] [`std::pair< Stepper::time_type , Stepper::time_type >`] [Performs one step using the ODE defined by `sys`. The step-size might be changed internally due to error control. This function returns a pair containing `t` and `t+dt` representing the interval for which interpolation can be performed.] ]
-  [[Do step with reference] [`stepper.do_step( boost::ref( sys ) )`] [`std::pair< Stepper::time_type , Stepper::time_type >`] [Same as above with `System` as reference] ]
+
+  [/ [Do step with reference] [`stepper.do_step( boost::ref( sys ) )`] [`std::pair< Stepper::time_type , Stepper::time_type >`] [Same as above with `System` as reference] ]
+
  [[Do interpolation] [`stepper.calc_state( t_inter , x )`] [`void`] [Performs the interpolation to calculate /x(t[sub inter]/) where /t <= t[sub inter] <= t+dt/.]]
-  [[Get current time] [`stepper.current_time()`] [`Stepper::time_type&`] [Returns the current time /t+dt/ of the stepper, that is the end time of the last step and the starting time for the next call of `do_step`]]
-  [[Get current state] [`stepper.current_state()`] [`Stepper::state_type&`] [Returns the current state of the stepper, that is /x(t+dt)/, the state at the time returned by `stepper.current_time()`]] 
+
+  [[Get current time] [`stepper.current_time()`] [`const Stepper::time_type&`] [Returns the current time /t+dt/ of the stepper, that is the end time of the last step and the starting time for the next call of `do_step`]]
+
+  [[Get current state] [`stepper.current_state()`] [`const Stepper::state_type&`] [Returns the current state of the stepper, that is /x(t+dt)/, the state at the time returned by `stepper.current_time()`]] 
 ]

 [heading Models]

 * `dense_output_controlled_explicit_fsal< controlled_error_stepper_fsal< runge_kutta_dopri5 >`
 * `bulirsch_stoer_dense_out`
+* `rosenbrock4_dense_output`

 [endsect]
--- a/libs/numeric/odeint/doc/concepts/error_stepper.qbk
+++ b/libs/numeric/odeint/doc/concepts/error_stepper.qbk
@ -8,6 +8,29 @@ An error stepper following this Error Stepper concept is capable of doing one st
 Error Steppers can be Runge Kutta steppers, symplectic steppers as well as implicit steppers.
 Based on the stepper type, the ODE is defined as __system, __symplectic_system, __simple_symplectic_system or __implicit_system.

+[heading Associated types]
+
+*  '''<para>'''[*state_type]'''</para>'''
+'''<para>'''`Stepper::state_type`'''</para>'''
+'''<para>'''The type characterizing the state of the ODE, hence ['x].'''</para>'''
+
+*  '''<para>'''[*deriv_type]'''</para>'''
+'''<para>'''`Stepper::deriv_type`'''</para>'''
+'''<para>'''The type characterizing the derivative of the ODE, hence ['d x/dt].'''</para>'''
+
+*  '''<para>'''[*time_type]'''</para>'''
+'''<para>'''`Stepper::time_type`'''</para>'''
+'''<para>'''The type characterizing the dependent variable of the ODE, hence the time ['t].'''</para>'''
+
+*  '''<para>'''[*value_type]'''</para>'''
+'''<para>'''`Stepper::value_type`'''</para>'''
+'''<para>'''The numerical data type which is used within the stepper, something like `float`, `double`, `complex&lt; double &gt;`.'''</para>'''
+
+*  '''<para>'''[*order_type]'''</para>'''
+'''<para>'''`Stepper::order_type`'''</para>'''
+'''<para>'''The type characterizing the order of the ODE, typically `unsigned short`.'''</para>'''
+
+
 [heading Notation]

 [variablelist 
@ -26,14 +49,17 @@ Based on the stepper type, the ODE is defined as __system, __symplectic_system,

 [table
  [[Name] [Expression] [Type] [Semantics]]
+  [[Get the stepper order] [`stepper.stepper_order()`] [`order_type`] [Returns the order of the stepper which is used for error calculation.]]
+  [[Get the error order] [`stepper.errorr_order()`] [`order_type`] [Returns the order of the error step which is used for error calculation.]]
  [[Do step] [`stepper.do_step( sys , x , t , dt , xerr )`] [`void`] [Performs one step of step size `dt` with error estimation.  The newly obtained state is written in-place to `x` and the estimated error to `xerr`.] ]
-  [[Do step with reference] [`stepper.do_step( boost::ref(sys) , x , t , dt , xerr )`] [`void`] [Performs one step of step size `dt`.  The newly obtained state is written in-place to `x` and the estimated error to `xerr`.] ]
+  [/ [Do step with reference] [`stepper.do_step( boost::ref(sys) , x , t , dt , xerr )`] [`void`] [Performs one step of step size `dt`.  The newly obtained state is written in-place to `x` and the estimated error to `xerr`.] ]
 ]

 [heading Models]

-* runge_kutta_cash_karp54
-* runge_kutta_dopri5
-* runge_kutta_fehlberg78
+* `runge_kutta_cash_karp54`
+* `runge_kutta_dopri5`
+* `runge_kutta_fehlberg78`
+* `rosenbrock4`

 [endsect]
--- a/libs/numeric/odeint/doc/concepts/stepper.qbk
+++ b/libs/numeric/odeint/doc/concepts/stepper.qbk
@ -15,7 +15,7 @@ Note that all error steppers are also basic steppers.
 * DefaultConstructable
 * CopyConstructable

-[/
+
 [heading Associated types]

 *  '''<para>'''[*state_type]'''</para>'''
@ -37,7 +37,7 @@ Note that all error steppers are also basic steppers.
 *  '''<para>'''[*order_type]'''</para>'''
 '''<para>'''`Stepper::order_type`'''</para>'''
 '''<para>'''The type characterizing the order of the ODE, typically `unsigned short`.'''</para>'''
-]
+

 [heading Notation]

@ -55,18 +55,22 @@ Note that all error steppers are also basic steppers.

 [table
  [[Name] [Expression] [Type] [Semantics]]
-  [/[Get the order] [`stepper.order()`] [`Order`] [Returns the order of the stepper which is used for error calculation.] ]
+  [[Get the order] [`stepper.order()`] [`order_type`] [Returns the order of the stepper.]]
  [[Do step] [`stepper.do_step( sys , x , t , dt )`] [`void`] [Performs one step of step size `dt`.  The newly obtained state is written in place in `x`.] ]
-  [[Do step with reference] [`stepper.do_step( boost::ref(sys) , x , t , dt )`] [`void`] [Performs one step of step size `dt`.  The newly obtained state is written in place in `x`.] ]
-  [/[Do step out-of-place] [`stepper.do_step( sys , in , t , out , dt )`] [`void`] [Performs one step. The newly obtained state is written to `out`] ]
+
+  [/ [Do step with reference] [`stepper.do_step( boost::ref(sys) , x , t , dt )`] [`void`] [Performs one step of step size `dt`.  The newly obtained state is written in place in `x`.] ]
+
+  [/ [Do step out-of-place] [`stepper.do_step( sys , in , t , out , dt )`] [`void`] [Performs one step. The newly obtained state is written to `out`] ]
 ]

 [heading Models]

-* runge_kutta4
-* euler
-* runge_kutta_cash_karp54
-* runge_kutta_dopri5
-* runge_kutta_fehlberg78
+* `runge_kutta4`
+* `euler`
+* `runge_kutta_cash_karp54`
+* `runge_kutta_dopri5`
+* `runge_kutta_fehlberg78`
+* `modified_midpoint`
+* `rosenbrock4`

 [endsect]