Syntax

Description

[t,y] =
ode15s(odefun,tspan,y0),
where tspan = [t0 tf], integrates the system of
differential equations y'=f(t,y) from t0 to tf with
initial conditions y0. Each row in the solution
array y corresponds to a value returned in column
vector t.

All MATLAB® ODE solvers can solve systems of equations of
the form y'=f(t,y),
or problems that involve a mass matrix, M(t,y)y'=f(t,y).
The solvers all use similar syntaxes. The ode23s solver
only can solve problems with a mass matrix if the mass matrix is constant. ode15s and ode23t can
solve problems with a mass matrix that is singular, known as differential-algebraic
equations (DAEs). Specify the mass matrix using the Mass option
of odeset.

[t,y] =
ode15s(odefun,tspan,y0,options) also
uses the integration settings defined by options,
which is an argument created using the odeset function.
For example, use the AbsTol and RelTol options
to specify absolute and relative error tolerances, or the Mass option
to provide a mass matrix.

[t,y,te,ye,ie]
= ode15s(odefun,tspan,y0,options) additionally
finds where functions of (t,y),
called event functions, are zero. In the output, te is
the time of the event, ye is the solution at the
time of the event, and ie is the index of the triggered
event.

For each event function, specify whether the integration is
to terminate at a zero and whether the direction of the zero crossing
matters. Do this by setting the 'Events' property
to a function, such as myEventFcn or @myEventFcn,
and creating a corresponding function: [value,isterminal,direction]
= myEventFcn(t,y).
For more information, see ODE Event Location.

sol = ode15s(___) returns
a structure that you can use with deval to evaluate
the solution at any point on the interval [t0 tf].
You can use any of the input argument combinations in previous syntaxes.

Examples

ODE With Single Solution Component

Simple ODEs that have a single solution component can be specified as an anonymous function in the call to the solver. The anonymous function must accept two inputs (t,y) even if one of the inputs is not used.

Solve the ODE

Use a time interval of [0,2] and the initial condition y0 = 1.

tspan = [0 2];
y0 = 1;
[t,y] = ode15s(@(t,y) -10*t, tspan, y0);

Plot the solution.

plot(t,y,'-o')

Solve Stiff ODE

An example of a stiff system of equations is the van der Pol equations in relaxation oscillation. The limit cycle has regions where the solution components change slowly and the problem is quite stiff, alternating with regions of very sharp change where it is not stiff.

The system of equations is:

The initial conditions are and . The function vdp1000 ships with MATLAB® and encodes the equations.

Solving this system using ode45 with the default relative and absolute error tolerances (1e-3 and 1e-6, respectively) is extremely slow, requiring several minutes to solve and plot the solution. ode45 requires millions of time steps to complete the integration, due to the areas of stiffness where it struggles to meet the tolerances.

This is a plot of the solution obtained by ode45, which takes a long time to compute. Notice the enormous number of time steps required to pass through areas of stiffness.

Solve the stiff system using the ode15s solver, and then plot the first column of the solution y against the time points t. The ode15s solver passes through stiff areas with far fewer steps than ode45.

[t,y] = ode15s(@vdp1000,[0 3000],[2 0]);
plot(t,y(:,1),'-o')

Pass Extra Parameters to ODE Function

ode15s only works with functions that use two input arguments, t and y. However, you can pass in extra parameters by defining them outside the function and passing them in when you specify the function handle.

Solve the ODE

Rewriting the equation as a first-order system yields

odefcn.m represents this system of equations as a function that accepts four input arguments: t, y, A, and B.

Compare Stiff ODE Solvers

The ode15s solver is a good first choice for most stiff problems. However, the other stiff solvers might be more efficient for certain types of problems. This example solves a stiff test equation using all four stiff ODE solvers.

Consider the test equation

The equation becomes increasingly stiff as the magnitude of increases. Use and the initial condition over the time interval [0 0.5]. With these values, the problem is stiff enough that ode45 and ode23 struggle to integrate the equation. Also, use odeset to pass in the constant Jacobian and turn on the display of solver statistics.

The stiff solvers all perform well, but ode23s completes the integration with the fewest steps and runs the fastest for this particular problem. Since the constant Jacobian is specified, none of the solvers need to calculate partial derivatives to compute the solution. Specifying the Jacobian benefits ode23s the most since it normally evaluates the Jacobian in every step.

For general stiff problems, the performance of the stiff solvers varies depending on the format of the problem and specified options. Providing the Jacobian matrix or sparsity pattern always improves solver efficiency for stiff problems. But since the stiff solvers use the Jacobian differently, the improvement can vary significantly. Practically speaking, if a system of equations is very large or needs to be solved many times, then it is worthwhile to investigate the performance of the different solvers to minimize execution time.

Evaluate and Extend Solution Structure

Solve the van der Pol equation with using ode15s. The function vdp1000.m ships with MATLAB® and encodes the equations. Specify a single output to return a structure containing information about the solution, such as the solver and evaluation points.

This example reformulates a system of ODEs as a system of differential algebraic equations (DAEs). The Robertson problem found in hb1ode.m is a classic test problem for programs that solve stiff ODEs. The system of equations is

hb1ode solves this system of ODEs to steady state with the initial conditions , , and . But the equations also satisfy a linear conservation law,

In terms of the solution and initial conditions, the conservation law is

The system of equations can be rewritten as a system of DAEs by using the conservation law to determine the state of . This reformulates the problem as the DAE system

The differential index of this system is 1, since only a single derivative of is required to make this a system of ODEs. Therefore, no further transformations are required before solving the system.

The function robertsdae encodes this DAE system. Save robertsdae.m in your current folder to run the example.

Input Arguments

odefun — Functions to solvefunction handle

Functions to solve, specified as a function handle which defines
the functions to be integrated.

The function dydt = odefun(t,y), for a scalar t and
a column vector y, must return a column vector dydt of
data type single or double that
corresponds to f(t,y). odefun must
accept both input arguments, t and y,
even if one of the arguments is not used in the function.

For example, to solve y'=5y−3,
use the function:

function dydt = odefun(t,y)
dydt = 5*y-3;

For a system of equations, the output of odefun is
a vector. Each element in the vector is the solution to one equation.
For example, to solve

tspan — Interval of integrationvector

Interval of integration, specified as a vector. At minimum, tspan must
be a two element vector [t0 tf] specifying the
initial and final times. To obtain solutions at specific times between t0 and tf,
use a longer vector of the form [t0,t1,t2,...,tf].
The elements in tspan must be all increasing or
all decreasing.

The solver imposes the initial conditions, y0,
at tspan(1), then integrates from tspan(1) to tspan(end):

If tspan has two elements, [t0
tf], then the solver returns the solution evaluated at each
internal integration step within the interval.

If tspan contains more than two
elements [t0,t1,t2,...,tf], then the solver returns
the solution evaluated at the given points. This does not affect
the internal steps that the solver uses to traverse from tspan(1) to tspan(end).
Thus, the solver does not necessarily step precisely to each point
specified in tspan. However, the solutions produced
at the specified points are of the same order of accuracy as the solutions
computed at each internal step.

Specifying several intermediate points has little effect on
the efficiency of computation, but for large systems it can affect
memory management.

The solution obtained by the solver might be different depending
on whether you specify tspan as a two-element vector
or as a vector with intermediate points. If tspan contains
several intermediate points, then they give an indication of the scale
for the problem, which can affect the size of the initial step taken
by the solver.

Example: [1 10]

Example: [1
3 5 7 9 10]

Data Types: single | double

y0 — Initial conditionsvector

Initial conditions, specified as a vector. y0 must
be the same length as the vector output of odefun,
so that y0 contains an initial condition for each
equation defined in odefun.

Data Types: single | double

options — Option structurestructure array

Option structure, specified as a structure array. Use the odeset function to create or modify the
options structure. See Summary of ODE Options for a list of the options compatible
with each solver.

Example: options = odeset('RelTol',1e-5,'Stats','on','OutputFcn',@odeplot) specifies
a relative error tolerance of 1e-5, turns on the
display of solver statistics, and specifies the output function @odeplot to
plot the solution as it is computed.

Output Arguments

t — Evaluation pointscolumn vector

If tspan contains two elements, [t0
tf], then t contains the internal evaluation
points used to perform the integration.

If tspan contains more than two
elements, then t is the same as tspan.

y — Solutionsarray

Solutions, returned as an array. Each row in y corresponds
to the solution at the value returned in the corresponding row of t.

te — Time of eventscolumn vector

Time of events, returned as a column vector. The event times
in te correspond to the solutions returned in ye,
and ie specifies which event occurred.

ye — Solution at time of eventsarray

Solution at time of events, returned as an array. The event
times in te correspond to the solutions returned
in ye, and ie specifies which
event occurred.

ie — Index of vanishing event functioncolumn vector

Index of vanishing event function, returned as a column vector.
The event times in te correspond to the solutions
returned in ye, and ie specifies
which event occurred.

sol — Structure for evaluationstructure array

Structure for evaluation, returned as a structure array. Use
this structure with the deval function
to evaluate the solution at any point in the interval [t0
tf]. The sol structure array always includes
these fields:

Structure Field

Description

sol.x

Row vector of the steps chosen by the solver.

sol.y

Solutions. Each column sol.y(:,i) contains
the solution at time sol.x(i).

sol.solver

Solver name.

Additionally, if you specify
the Events option and events are detected, then sol also
includes these fields:

Structure Field

Description

sol.xe

Points when events occurred. sol.xe(end) contains
the exact point of a terminal event, if any.

sol.ye

Solutions that correspond to events in sol.xe.

sol.ie

Indices into the vector returned by the function specified
in the Events option. The values indicate which
event the solver detected.

More About

Algorithms

ode15s is a variable-step, variable-order
(VSVO) solver based on the numerical differentiation formulas (NDFs)
of orders 1 to 5. Optionally, it can use the backward differentiation
formulas (BDFs, also known as Gear's method) that are usually less
efficient. Like ode113, ode15s is
a multistep solver. Use ode15s if ode45 fails
or is very inefficient and you suspect that the problem is stiff,
or when solving a differential-algebraic equation (DAE) [1], [2].