*(For more resources related to this topic, see here.)*

# Variable-step versus fixed-step solvers

A variable-step solver will choose to use a shorter time step when the signal derivative is changing faster in order to obtain a better approximation, while it will use a longer step when the result changes at a slower pace. The most used variable-step solver is the **ode45** solver (this is the default Simulink solver as well).

A fixed-step solver will, on the other hand, always use the same step size. The simplest is the **ode1** solver (the famous Euler method).

We've already run our example with a fixed-step solver. Let's change this to a variable-step solver by opening the **Model Configuration Parameters** window and setting the **ode45** solver.

We now have the option to configure more **Solver** parameters; we'll allow it to use a **Max step size** of *1* second and a **Min step size** of *0.2* seconds, setting other parameters to the default value. Running the simulation now will give us the following result:

We can see that the step size is indeed variable: the second value has been computed after only 0.2 seconds, and then the step size grew bigger and stayed at 1 second. We got a good approximation in the problematic region while using longer steps in the almost constant region, thus achieving a faster simulation time than a fixed-step solver with a step size of 0.2 seconds.

But how does the solver determine when it's necessary to reduce the step size? The answer is by looking at the tolerances defined in the **Model Configuration Parameters** window.

**Relative tolerance** defines the maximum error as a percentage of the actual value. The default value (*1e-3*) means that an error of 0.1 percent is accepted.

**Absolute tolerance** defines the maximum error as a scalar value. When it is set to *auto*, Simulink will assume *1e-6* initially (that is, *0.000001*), then change it to the maximum error calculated with the relative tolerance.

The **Shape preservation** option, off ( **Disable all** ) by default, helps to increase the accuracy when the solution's derivative varies rapidly at the cost of a more computing-intensive simulation (thus increasing the overall time to compute the result).

Finally, there's the option **Number of consecutive min steps** , which defines how many times the solver can use a time step smaller than the minimum step size violations defined before issuing a warning or an error.

Let's set the **Relative tolerance** parameter to *1e-5* and run the simulation. We'll obtain this result:

This time, the solver chose to use more shorter steps while the signal was changing to improve the accuracy, thanks to the relative tolerance we've set; then the step size grew gradually back to 1 second.

Variable-step solvers give us a good trade-off between result approximation and overall simulation times in models, whereas fixed-step solvers are too computationally intensive to be used efficiently.

*Fixed-step solvers are required for code generation and real-time control purposes because Simulink can't go back in time to give a more accurate result.*

# Continuous versus discrete

A system can be continuous or discrete based on the presence of integrators or derivatives in the model (these are called continuous states). In other words, if the system is represented by the means of one or more differential equations, the system is continuous. Our cruise controller is continuous because it has an integral component.

The continuous solver can choose to perform several iteration cycles in a single time step to reach the best possible approximation of the final result. Such solvers fall into the **ODE** ( **Ordinary Differential Equation** solvers) category.

If a system is discrete, there are no differential equations but only memories and mathematical operands. A discrete solver is unable to perform the numerical integration required by continuous states.

The continuous system requires continuous solvers, while Simulink will switch to a discrete solver for discrete systems even if a continuous solver has been specified.

Try to set a discrete solver in our example system and run a simulation. An error window will appear, telling us that a discrete solver can't be used because the model contains continuous states.

# Stiff versus nonstiff

In a stiff continuous system, certain solvers are unable to compute the result unless the step size is small enough; thus, a stiff solver is needed. These systems can be identified by an overall slowly changing solution that can vary rapidly in a very small time period.

Our example is mildly stiff: the ode45 solver had to use a small step size to compute the result close to t = 0, but it managed to get the job done by changing the time step. A more appropriate choice would have been the **ode23t** solver (moderately stiff), which would have given the following result:

Let's choose another nonstiff solver, the fixed-step **ode1** , implementing the Euler method. Set the **Fixed step size** parameter to *1.5* and run the simulation:

That's interesting: Using the Euler method with a long time step shows the result to be oscillating around the mathematical result, but the solution is still convergent.

Setting the step size to *2* seconds will show that it can't converge anymore, and any step size higher than *2* seconds will make the simulation diverge from the correct result and go towards infinite oscillation. The following figure shows the result with a step size of *2.1* and a simulation time of *20* seconds:

*The following article presents stiff solvers in a way that is easy to understand: http://blogs.mathworks.com/seth/2012/07/03/why-do-we-need-stiff-ode-solvers/.*

*The documentation center, accessible by pressing F1 , has detailed information about the solver types and parameters. This information can be found by navigating to Simulink | Simulation | Configure simulation .*

# Summary

In this article, we've learned how solvers work and how to choose the right solver to run the simulations

## Resources for Article:

**Further resources on this subject:**

- 2-Dimensional Image Filtering [Article]
- GoboLinux: An Interview with Lucas Villa Real [Article]
- The NGINX HTTP Server [Article]