Change language to:
English - Français - Português - Русский

See the recommended documentation of this function

Scilabヘルプ >> Xcos > Solvers > Comparisons

# Comparisons

This page compares solvers to determine which one is best fitted for the studied problem.

### Introduction

Following the type of problem, finding out which method to use is not always obvious, only general guidelines can be established. Those are discussed in this page.

### Variable-size and Fixed-size

The solvers can be divided into two distinct main families: the Variable-size and the Fixed-size step methods.

They both compute the next simulation time as the sum of the current simulation time and a quantity known as the step size, which is constant in the Fixed-size solvers and can change in the Variable-size ones, depending on the model dynamics and the input tolerances.

If looking for stable computation time, the user should select a Fixed-size step solver, because the computation overhead for a Variable-size step method cannot be properly predicted.

Although for a simple problem (or loose tolerances) a Variable-size solver can significantly improve the simulation time by computing bigger step sizes, a Fixed-size method is preferable if the ideal step size is known and roughly constant (the user should then mention it in max step size).

Variable-size step solvers:

• LSodar
• CVode
• IDA
Fixed-size step solvers:
• Runge-Kutta 4(5)
• Dormand-Prince 4(5)
• Implicit Runge-Kutta 4(5)

Variable step-size ODE solvers are not appropriate for deterministic real-time applications because the computational overhead of taking a time step varies over the course of an application.

### Explicit and Implicit - Stiffness

Within these two families, we can distinguish Explicit solvers from Implicit ones.

While explicit methods only use data available on the current step, the implicit ones will attempt to compute derivatives at further times. In order to do this, they use nonlinear solvers such as fixed-point iterations, functional iterations (nonstiff) or modified Newton methods (stiff).

The family choice is usually determined by the stiffness of the problem, which is, when there is a big gap between the biggest and the smallest eigen values modules of the jacobian matrix (when it is ill-conditionned). It is generally a system that is sensitive to discontinuitues, meaning that the required precision is not constant.

Implicit solvers:

• LSodar
• CVode
• IDA
• Implicit Runge-Kutta 4(5)
Explicit solvers:
• Runge-Kutta 4(5)
• Dormand-Prince 4(5)

To put it simply, the Explicit go straight to a computation of the solution, whereas the Implicit concentrate on stability, involving more operations, following the tolerances.

### So how to choose ?

Because it is not possible to know for sure whether a solver will be efficient for a given system or not, the best way is to run the most probable one on it and to compare their results.

The user should first establish the complexity of his problem (stability / stiffness) and if he desires high precision, rapid simulation, predictable time or an automated program.

Precision: CVode,

Predictable time: Fixed-size step.

Simulation time: LSodar,

Automated: LSodar,

### Examples - ODEs

We will begin with a simple nonstiff example: a Sine integration.

In the following script, we compare the time difference between the solvers by running the example with the eight solvers in turn (IDA doesn't handle this kind of problem): Open the script

The Scilab console displays:

```Time for LSodar:
10.1

Time for CVode BDF/Newton:
31

Time for CVode BDF/Functional:
30

17.211

16.305

Time for Dormand-Prince:
12.92

Time for Runge-Kutta:
7.663

Time for implicit Runge-Kutta:
10.881
```

These results show that on a nonstiff problem and for same precision required, Runge-Kutta is fastest.

In spite of the computational overhead of the step size, LSodar is not too distant from the Fixed-size solvers because it is able to take long steps.

From the results, we can extract speed factors and set the following table:

 BDF / Newton BDF / Functional Adams / Newton Adams / Functional Dormand-Prince Runge-Kutta Implicit Runge-Kutta LSodar 3.1x 3x 1.7x 1.6x 1.3x 0.75x 1.08x BDF / Newton 0.1x 0.6x 0.5x 0.4x 0.25x 0.35x BDF / Functional 0.6x 0.5x 0.4x 0.25x 0.4x Adams / Newton 0.9x 0.75x 0.45x 0.6x Adams / Functional 0.8x 0.5x 0.7x Dormand-Prince 0.6x 0.8x Runge-Kutta 1.4x

Next, a basic controller with six continuous states is tested.

In the following script, we compare the time difference between the solvers by running the example with the eight solvers in turn (IDA doesn't handle this kind of problem): Open the script

The Scilab console displays:

```Time for LSodar:
10

Time for CVode BDF/Newton:
28.254

Time for CVode BDF/Functional:
25.545

15

12.1

Time for Dormand-Prince:
2.359

Time for Runge-Kutta:
1.671

Time for implicit Runge-Kutta:
5.612
```

These results show that as stiffness appears, BDF / Newton starts picking up speed. But the problem is not yet complicated enough for that method to be interesting.

The updated speed factors table is as follows:

 BDF / Newton BDF / Functional Adams / Newton Adams / Functional Dormand-Prince Runge-Kutta Implicit Runge-Kutta LSodar 2.8x 2.6x 1.5x 1.2x 0.2x 0.17x 0.5x BDF / Newton 0.9x 0.5x 0.4x 0.1x 0.05x 0.2x BDF / Functional 0.6x 0.5x 0.1x 0.07x 0.2x Adams / Newton 0.8x 0.15x 0.1x 0.4x Adams / Functional 0.2x 0.1x 0.5x Dormand-Prince 0.7x 2.4x Runge-Kutta 3.4x

Now, we use Kalman's filter, which contains fifteen continuous states.

In the following script, we compare the time difference between the solvers by running the example with the eight solvers in turn (IDA doesn't handle this kind of problem): Open the script

The Scilab console displays:

```Time for LSodar:
10

Time for CVode BDF/Newton:
21.3

Time for CVode BDF/Functional:
15.8

12.5

8.67

Time for Dormand-Prince:
1.244

Time for Runge-Kutta:
0.87

Time for implicit Runge-Kutta:
4
```

These results show that for a bigger problem (more continuous states implies more equations), the Newton iteration starts showing interest, for it comes closer to the other solvers.

The updated speed factors table is as follows:

 BDF / Newton BDF / Functional Adams / Newton Adams / Functional Dormand-Prince Runge-Kutta Implicit Runge-Kutta LSodar 2.1x 1.6x 1.3x 0.85x 0.1x 0.1x 0.4x BDF / Newton 0.75x 0.6x 0.4x 0.06x 0.05x 0.2x BDF / Functional 0.8x 0.55x 0.08x 0.06x 0.25x Adams / Newton 0.7x 0.1x 0.07x 0.3x Adams / Functional 0.15x 0.1x 0.5x Dormand-Prince 0.7x 3.2x Runge-Kutta 4.6x

### Examples - DAEs

In this section we compare IDA with DDaskr.

Example: a bouncing ball.

In the following script, we compare the time difference between the solvers by running the example with the three solvers in turn: Open the script

The Scilab console displays:

```Time for IDA:
8

5.6

6.5
```

This result shows that on a stiff problem, with rootfinding and for same precision required, DDaskr - Newton is fastest.

The difference in time is attributed to the powerful implementation of DDaskr and its least error control.

GMRes is slower due to the small size of the problem.

From the results, we can extract the speed factors:

The next example simply corroborates the previous one, it is shorter but more thorough, since it deals with the filling and emptying of a tank.

In the following script, we compare the time difference between the solvers by running the example with the three solvers in turn: Open the script

The Scilab console displays:

```Time for IDA:
3

0.8