GNU Scientific Library Reference Manual - Third Edition (v1.12)by M. Galassi, J. Davies, J. Theiler, B. Gough, G. Jungman, P. Alken, M. Booth, F. Rossi Paperback (6"x9"), 592 pages, 60 figures ISBN 0954612078 RRP £24.95 ($39.95) |

## 25.3 Adaptive Step-size Control

The control function examines the proposed change to the solution produced by a stepping function and attempts to determine the optimal step-size for a user-specified level of error.

__Function:__gsl_odeiv_control ***gsl_odeiv_control_standard_new***(double*`eps_abs`, double`eps_rel`, double`a_y`, double`a_dydt`)- The standard control object is a four parameter heuristic based on
absolute and relative errors
`eps_abs`and`eps_rel`, and scaling factors`a_y`and`a_dydt`for the system state y(t) and derivatives y'(t) respectively.The step-size adjustment procedure for this method begins by computing the desired error level D_i for each component,

D_i = eps_abs + eps_rel * (a_y |y_i| + a_dydt h |y'_i|)

and comparing it with the observed error E_i = |yerr_i|. If the observed error

`E`exceeds the desired error level`D`by more than 10% for any component then the method reduces the step-size by an appropriate factor,h_new = h_old * S * (E/D)^(-1/q)

where q is the consistency order of the method (e.g. q=4 for 4(5) embedded RK), and S is a safety factor of 0.9. The ratio E/D is taken to be the maximum of the ratios E_i/D_i.

If the observed error E is less than 50% of the desired error level

`D`for the maximum ratio E_i/D_i then the algorithm takes the opportunity to increase the step-size to bring the error in line with the desired level,h_new = h_old * S * (E/D)^(-1/(q+1))

This encompasses all the standard error scaling methods. To avoid uncontrolled changes in the stepsize, the overall scaling factor is limited to the range 1/5 to 5.

__Function:__gsl_odeiv_control ***gsl_odeiv_control_y_new***(double*`eps_abs`, double`eps_rel`)- This function creates a new control object which will keep the local
error on each step within an absolute error of
`eps_abs`and relative error of`eps_rel`with respect to the solution y_i(t). This is equivalent to the standard control object with`a_y`=1 and`a_dydt`=0.

__Function:__gsl_odeiv_control ***gsl_odeiv_control_yp_new***(double*`eps_abs`, double`eps_rel`)- This function creates a new control object which will keep the local
error on each step within an absolute error of
`eps_abs`and relative error of`eps_rel`with respect to the derivatives of the solution y'_i(t). This is equivalent to the standard control object with`a_y`=0 and`a_dydt`=1.

__Function:__gsl_odeiv_control ***gsl_odeiv_control_scaled_new***(double*`eps_abs`, double`eps_rel`, double`a_y`, double`a_dydt`, const double`scale_abs`[], size_t`dim`)- This function creates a new control object which uses the same algorithm
as
`gsl_odeiv_control_standard_new`

but with an absolute error which is scaled for each component by the array`scale_abs`. The formula for D_i for this control object is,D_i = eps_abs * s_i + eps_rel * (a_y |y_i| + a_dydt h |y'_i|)

where s_i is the i-th component of the array

`scale_abs`. The same error control heuristic is used by the Matlab ode suite.

__Function:__gsl_odeiv_control ***gsl_odeiv_control_alloc***(const gsl_odeiv_control_type **`T`)- This function returns a pointer to a newly allocated instance of a
control function of type
`T`. This function is only needed for defining new types of control functions. For most purposes the standard control functions described above should be sufficient.

__Function:__int**gsl_odeiv_control_init***(gsl_odeiv_control **`c`, double`eps_abs`, double`eps_rel`, double`a_y`, double`a_dydt`)- This function initializes the control function
`c`with the parameters`eps_abs`(absolute error),`eps_rel`(relative error),`a_y`(scaling factor for y) and`a_dydt`(scaling factor for derivatives).

__Function:__void**gsl_odeiv_control_free***(gsl_odeiv_control **`c`)- This function frees all the memory associated with the control function
`c`.

__Function:__int**gsl_odeiv_control_hadjust***(gsl_odeiv_control **`c`, gsl_odeiv_step *`s`, const double`y`[], const double`yerr`[], const double`dydt`[], double *`h`)- This function adjusts the step-size
`h`using the control function`c`, and the current values of`y`,`yerr`and`dydt`. The stepping function`step`is also needed to determine the order of the method. If the error in the y-values`yerr`is found to be too large then the step-size`h`is reduced and the function returns`GSL_ODEIV_HADJ_DEC`

. If the error is sufficiently small then`h`may be increased and`GSL_ODEIV_HADJ_INC`

is returned. The function returns`GSL_ODEIV_HADJ_NIL`

if the step-size is unchanged. The goal of the function is to estimate the largest step-size which satisfies the user-specified accuracy requirements for the current point.

__Function:__const char ***gsl_odeiv_control_name***(const gsl_odeiv_control **`c`)- This function returns a pointer to the name of the control function.
For example,
printf ("control method is '%s'\n", gsl_odeiv_control_name (c));

would print something like

`control method is 'standard'`

ISBN 0954612078 | GNU Scientific Library Reference Manual - Third Edition (v1.12) | See the print edition |