Radau IIA fifth-order three-stages with step-size control and continuous output. Based on the FORTRAN code RADAU5 by E.Hairer and G.Wanner, which can be found here: http://www.unige.ch/~hairer/software.html

Details about the implementation (FORTRAN) can be found in the book,:

```
Solving Ordinary Differential Equations II,
Stiff and Differential-Algebraic Problems
Authors: E. Hairer and G. Wanner
Springer-Verlag, ISBN: 3-540-60452-9
```

- State events (root funtions) : True
- Step events (completed step) : True
- Time events : True

Import the solver together with the correct problem:

```
from assimulo.solvers import Radau5DAE
from assimulo.problem import Implicit_Problem
```

Define the problem, such as:

```
def res(t, y, yd): #Note that y and yd are 1-D numpy arrays.
res = yd[0]-1.0
return N.array([res]) #Note that the return must be numpy array, NOT a scalar.
y0 = [1.0]
yd0 = [1.0]
t0 = 1.0
```

Create a problem instance:

```
mod = Implicit_Problem(res, y0, yd0, t0)
```

Note

For complex problems, it is recommended to check the available examples and the documentation in the problem class, `Implicit_Problem`

. It is also recommended to define your problem as a subclass of `Implicit_Problem`

.

Warning

When subclassing from a problem class, the function for calculating the right-hand-side (for ODEs) must be named *rhs* and in the case with a residual function (for DAEs) it must be named *res*.

Create a solver instance:

```
sim = Radau5DAE(mod)
```

Modify (optionally) the solver parameters.

Parameters:

`atol`

Defines the absolute tolerance(s) that is to be used by the solver.`backward`

Specifies if the simulation is done in reverse time.`clock_step`

Specifies if the elapsed time of an integrator step should be timed or not.`display_progress`

This option actives output during the integration in terms of that the current integration is periodically printed to the stdout.`fac1`

Parameters for step-size selection.`fac2`

Parameters for step-size selection.`fnewt`

Stopping criterion for Newton’s method, usually chosen <1.`inith`

This determines the initial step-size to be used in the integration.`maxh`

Defines the maximal step-size that is to be used by the solver.`maxsteps`

The maximum number of steps allowed to be taken to reach the final time.`newt`

Maximal number of Newton iterations.`num_threads`

This options specifies the number of threads to be used for those solvers that supports it.`quot1`

If quot1 < current step-size / old step-size < quot2 the the step-size is not changed.`quot2`

If quot1 < current step-size / old step-size < quot2 the the step-size is not changed.`report_continuously`

This options specifies if the solver should report the solution continuously after steps.`rtol`

Defines the relative tolerance that is to be used by the solver.`safe`

The safety factor in the step-size prediction.`store_event_points`

This options specifies if the solver should save additional points at the events, \(t_e^-, t_e^+\).`thet`

Value for determine if the Jacobian is to be recomputed or not.`time_limit`

This option can be used to limit the time of an integration.`usejac`

This sets the option to use the user defined jacobian.`verbosity`

This determines the level of the output.

Methods:

`Radau5DAE.interpolate`

Simulate the problem:

Information:

`Radau5DAE.get_options()`

Returns the current solver options.`Radau5DAE.get_supports()`

Returns the functionality which the solver supports.`Radau5DAE.get_statistics()`

Returns the run-time statistics (if any).`Radau5DAE.get_event_data()`

Returns the event information (if any).`Radau5DAE.print_event_data()`

Prints the event information (if any).`Radau5DAE.print_statistics()`

Prints the run-time statistics for the problem.