(octave.info)Matlab-compatible solvers
24.1.1 Matlab-compatible solvers
--------------------------------
Octave also provides a set of solvers for initial value problems for
Ordinary Differential Equations that have a MATLAB-compatible interface.
The options for this class of methods are set using the functions.
• ‘odeset’
• ‘odeget’
Currently implemented solvers are:
• Runge-Kutta methods
• ‘ode23’ integrates a system of non-stiff ordinary differential
equations (ODEs) or index-1 differential-algebraic equations
(DAEs). It uses the third-order Bogacki-Shampine method and
adapts the local step size in order to satisfy a
user-specified tolerance. The solver requires three function
evaluations per integration step.
• ‘ode45’ integrates a system of non-stiff ODEs (or index-1
DAEs) using the high-order, variable-step Dormand-Prince
method. It requires six function evaluations per integration
step, but may take larger steps on smooth problems than
‘ode23’: potentially offering improved efficiency at smaller
tolerances.
• Linear multistep methods
• ‘ode15s’ integrates a system of stiff ODEs (or index-1 DAEs)
using a variable step, variable order method based on Backward
Difference Formulas (BDF).
• ‘ode15i’ integrates a system of fully-implicit ODEs (or
index-1 DAEs) using the same variable step, variable order
method as ‘ode15s’. The function ‘decic’ can be used to
compute consistent initial conditions.
-- : [T, Y] = ode45 (FUN, TRANGE, INIT)
-- : [T, Y] = ode45 (FUN, TRANGE, INIT, ODE_OPT)
-- : [T, Y, TE, YE, IE] = ode45 (...)
-- : SOLUTION = ode45 (...)
-- : ode45 (...)
Solve a set of non-stiff Ordinary Differential Equations (non-stiff
ODEs) with the well known explicit Dormand-Prince method of order
4.
FUN is a function handle, inline function, or string containing the
name of the function that defines the ODE: ‘y' = f(t,y)’. The
function must accept two inputs where the first is time T and the
second is a column vector of unknowns Y.
TRANGE specifies the time interval over which the ODE will be
evaluated. Typically, it is a two-element vector specifying the
initial and final times (‘[tinit, tfinal]’). If there are more
than two elements then the solution will also be evaluated at these
intermediate time instances.
By default, ‘ode45’ uses an adaptive timestep with the
‘integrate_adaptive’ algorithm. The tolerance for the timestep
computation may be changed by using the options "RelTol" and
"AbsTol".
INIT contains the initial value for the unknowns. If it is a row
vector then the solution Y will be a matrix in which each column is
the solution for the corresponding initial value in INIT.
The optional fourth argument ODE_OPT specifies non-default options
to the ODE solver. It is a structure generated by ‘odeset’.
The function typically returns two outputs. Variable T is a column
vector and contains the times where the solution was found. The
output Y is a matrix in which each column refers to a different
unknown of the problem and each row corresponds to a time in T.
The output can also be returned as a structure SOLUTION which has a
field X containing a row vector of times where the solution was
evaluated and a field Y containing the solution matrix such that
each column corresponds to a time in X. Use
‘fieldnames (SOLUTION)’ to see the other fields and additional
information returned.
If no output arguments are requested, and no ‘OutputFcn’ is
specified in ODE_OPT, then the ‘OutputFcn’ is set to ‘odeplot’ and
the results of the solver are plotted immediately.
If using the "Events" option then three additional outputs may be
returned. TE holds the time when an Event function returned a
zero. YE holds the value of the solution at time TE. IE contains
an index indicating which Event function was triggered in the case
of multiple Event functions.
Example: Solve the Van der Pol equation
fvdp = @(T,Y) [Y(2); (1 - Y(1)^2) * Y(2) - Y(1)];
[T,Y] = ode45 (fvdp, [0, 20], [2, 0]);
See also: Note: odeset, Note: odeget, Note:
ode23, Note: ode15s.
-- : [T, Y] = ode23 (FUN, TRANGE, INIT)
-- : [T, Y] = ode23 (FUN, TRANGE, INIT, ODE_OPT)
-- : [T, Y, TE, YE, IE] = ode23 (...)
-- : SOLUTION = ode23 (...)
-- : ode23 (...)
Solve a set of non-stiff Ordinary Differential Equations (non-stiff
ODEs) with the well known explicit Bogacki-Shampine method of order
3.
FUN is a function handle, inline function, or string containing the
name of the function that defines the ODE: ‘y' = f(t,y)’. The
function must accept two inputs where the first is time T and the
second is a column vector of unknowns Y.
TRANGE specifies the time interval over which the ODE will be
evaluated. Typically, it is a two-element vector specifying the
initial and final times (‘[tinit, tfinal]’). If there are more
than two elements then the solution will also be evaluated at these
intermediate time instances.
By default, ‘ode23’ uses an adaptive timestep with the
‘integrate_adaptive’ algorithm. The tolerance for the timestep
computation may be changed by using the options "RelTol" and
"AbsTol".
INIT contains the initial value for the unknowns. If it is a row
vector then the solution Y will be a matrix in which each column is
the solution for the corresponding initial value in INIT.
The optional fourth argument ODE_OPT specifies non-default options
to the ODE solver. It is a structure generated by ‘odeset’.
The function typically returns two outputs. Variable T is a column
vector and contains the times where the solution was found. The
output Y is a matrix in which each column refers to a different
unknown of the problem and each row corresponds to a time in T.
The output can also be returned as a structure SOLUTION which has a
field X containing a row vector of times where the solution was
evaluated and a field Y containing the solution matrix such that
each column corresponds to a time in X. Use
‘fieldnames (SOLUTION)’ to see the other fields and additional
information returned.
If no output arguments are requested, and no ‘OutputFcn’ is
specified in ODE_OPT, then the ‘OutputFcn’ is set to ‘odeplot’ and
the results of the solver are plotted immediately.
If using the "Events" option then three additional outputs may be
returned. TE holds the time when an Event function returned a
zero. YE holds the value of the solution at time TE. IE contains
an index indicating which Event function was triggered in the case
of multiple Event functions.
Example: Solve the Van der Pol equation
fvdp = @(T,Y) [Y(2); (1 - Y(1)^2) * Y(2) - Y(1)];
[T,Y] = ode23 (fvdp, [0, 20], [2, 0]);
Reference: For the definition of this method see
<https://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods>.
See also: Note: odeset, Note: odeget, Note:
ode45, Note: ode15s.
-- : [T, Y] = ode15s (FUN, TRANGE, Y0)
-- : [T, Y] = ode15s (FUN, TRANGE, Y0, ODE_OPT)
-- : [T, Y, TE, YE, IE] = ode15s (...)
-- : SOLUTION = ode15s (...)
-- : ode15s (...)
Solve a set of stiff Ordinary Differential Equations (ODEs) or
stiff semi-explicit index 1 Differential Algebraic Equations
(DAEs).
‘ode15s’ uses a variable step, variable order BDF (Backward
Differentiation Formula) method that ranges from order 1 to 5.
FUN is a function handle, inline function, or string containing the
name of the function that defines the ODE: ‘y' = f(t,y)’. The
function must accept two inputs where the first is time T and the
second is a column vector of unknowns Y.
TRANGE specifies the time interval over which the ODE will be
evaluated. Typically, it is a two-element vector specifying the
initial and final times (‘[tinit, tfinal]’). If there are more
than two elements then the solution will also be evaluated at these
intermediate time instances.
INIT contains the initial value for the unknowns. If it is a row
vector then the solution Y will be a matrix in which each column is
the solution for the corresponding initial value in INIT.
The optional fourth argument ODE_OPT specifies non-default options
to the ODE solver. It is a structure generated by ‘odeset’.
The function typically returns two outputs. Variable T is a column
vector and contains the times where the solution was found. The
output Y is a matrix in which each column refers to a different
unknown of the problem and each row corresponds to a time in T.
The output can also be returned as a structure SOLUTION which has a
field X containing a row vector of times where the solution was
evaluated and a field Y containing the solution matrix such that
each column corresponds to a time in X. Use
‘fieldnames (SOLUTION)’ to see the other fields and additional
information returned.
If no output arguments are requested, and no ‘OutputFcn’ is
specified in ODE_OPT, then the ‘OutputFcn’ is set to ‘odeplot’ and
the results of the solver are plotted immediately.
If using the "Events" option then three additional outputs may be
returned. TE holds the time when an Event function returned a
zero. YE holds the value of the solution at time TE. IE contains
an index indicating which Event function was triggered in the case
of multiple Event functions.
Example: Solve Robertson’s equations:
function r = robertson_dae (T, Y)
r = [ -0.04*Y(1) + 1e4*Y(2)*Y(3)
0.04*Y(1) - 1e4*Y(2)*Y(3) - 3e7*Y(2)^2
Y(1) + Y(2) + Y(3) - 1 ];
endfunction
opt = odeset ("Mass", [1 0 0; 0 1 0; 0 0 0], "MStateDependence", "none");
[T,Y] = ode15s (@robertson_dae, [0, 1e3], [1; 0; 0], opt);
See also: Note: decic, Note: odeset, Note:
odeget, Note: ode23, Note: ode45.
-- : [T, Y] = ode15i (FUN, TRANGE, Y0, YP0)
-- : [T, Y] = ode15i (FUN, TRANGE, Y0, YP0, ODE_OPT)
-- : [T, Y, TE, YE, IE] = ode15i (...)
-- : SOLUTION = ode15i (...)
-- : ode15i (...)
Solve a set of fully-implicit Ordinary Differential Equations
(ODEs) or index 1 Differential Algebraic Equations (DAEs).
‘ode15i’ uses a variable step, variable order BDF (Backward
Differentiation Formula) method that ranges from order 1 to 5.
FUN is a function handle, inline function, or string containing the
name of the function that defines the ODE: ‘0 = f(t,y,yp)’. The
function must accept three inputs where the first is time T, the
second is the function value Y (a column vector), and the third is
the derivative value YP (a column vector).
TRANGE specifies the time interval over which the ODE will be
evaluated. Typically, it is a two-element vector specifying the
initial and final times (‘[tinit, tfinal]’). If there are more
than two elements then the solution will also be evaluated at these
intermediate time instances.
Y0 and YP0 contain the initial values for the unknowns Y and YP.
If they are row vectors then the solution Y will be a matrix in
which each column is the solution for the corresponding initial
value in Y0 and YP0.
Y0 and YP0 must be consistent initial conditions, meaning that
‘f(t,y0,yp0) = 0’ is satisfied. The function ‘decic’ may be used
to compute consistent initial conditions given initial guesses.
The optional fifth argument ODE_OPT specifies non-default options
to the ODE solver. It is a structure generated by ‘odeset’.
The function typically returns two outputs. Variable T is a column
vector and contains the times where the solution was found. The
output Y is a matrix in which each column refers to a different
unknown of the problem and each row corresponds to a time in T.
The output can also be returned as a structure SOLUTION which has a
field X containing a row vector of times where the solution was
evaluated and a field Y containing the solution matrix such that
each column corresponds to a time in X. Use
‘fieldnames (SOLUTION)’ to see the other fields and additional
information returned.
If no output arguments are requested, and no ‘OutputFcn’ is
specified in ODE_OPT, then the ‘OutputFcn’ is set to ‘odeplot’ and
the results of the solver are plotted immediately.
If using the "Events" option then three additional outputs may be
returned. TE holds the time when an Event function returned a
zero. YE holds the value of the solution at time TE. IE contains
an index indicating which Event function was triggered in the case
of multiple Event functions.
Example: Solve Robertson’s equations:
function r = robertson_dae (T, Y, YP)
r = [ -(YP(1) + 0.04*Y(1) - 1e4*Y(2)*Y(3))
-(YP(2) - 0.04*Y(1) + 1e4*Y(2)*Y(3) + 3e7*Y(2)^2)
Y(1) + Y(2) + Y(3) - 1 ];
endfunction
[T,Y] = ode15i (@robertson_dae, [0, 1e3], [1; 0; 0], [-1e-4; 1e-4; 0]);
See also: Note: decic, Note: odeset, Note:
odeget.
-- : [Y0_NEW, YP0_NEW] = decic (FUN, T0, Y0, FIXED_Y0, YP0, FIXED_YP0)
-- : [Y0_NEW, YP0_NEW] = decic (FUN, T0, Y0, FIXED_Y0, YP0, FIXED_YP0,
OPTIONS)
-- : [Y0_NEW, YP0_NEW, RESNORM] = decic (...)
Compute consistent implicit ODE initial conditions Y0_NEW and
YP0_NEW given initial guesses Y0 and YP0.
A maximum of ‘length (Y0)’ components between FIXED_Y0 and
FIXED_YP0 may be chosen as fixed values.
FUN is a function handle. The function must accept three inputs
where the first is time T, the second is a column vector of
unknowns Y, and the third is a column vector of unknowns YP.
T0 is the initial time such that ‘FUN(T0, Y0_NEW, YP0_NEW) = 0’,
specified as a scalar.
Y0 is a vector used as the initial guess for Y.
FIXED_Y0 is a vector which specifies the components of Y0 to hold
fixed. Choose a maximum of ‘length (Y0)’ components between
FIXED_Y0 and FIXED_YP0 as fixed values. Set FIXED_Y0(i) component
to 1 if you want to fix the value of Y0(i). Set FIXED_Y0(i)
component to 0 if you want to allow the value of Y0(i) to change.
YP0 is a vector used as the initial guess for YP.
FIXED_YP0 is a vector which specifies the components of YP0 to hold
fixed. Choose a maximum of ‘length (YP0)’ components between
FIXED_Y0 and FIXED_YP0 as fixed values. Set FIXED_YP0(i) component
to 1 if you want to fix the value of YP0(i). Set FIXED_YP0(i)
component to 0 if you want to allow the value of YP0(i) to change.
The optional seventh argument OPTIONS is a structure array. Use
‘odeset’ to generate this structure. The relevant options are
‘RelTol’ and ‘AbsTol’ which specify the error thresholds used to
compute the initial conditions.
The function typically returns two outputs. Variable Y0_NEW is a
column vector and contains the consistent initial value of Y. The
output YP0_NEW is a column vector and contains the consistent
initial value of YP.
The optional third output RESNORM is the norm of the vector of
residuals. If RESNORM is small, ‘decic’ has successfully computed
the initial conditions. If the value of RESNORM is large, use
‘RelTol’ and ‘AbsTol’ to adjust it.
Example: Compute initial conditions for Robertson’s equations:
function r = robertson_dae (T, Y, YP)
r = [ -(YP(1) + 0.04*Y(1) - 1e4*Y(2)*Y(3))
-(YP(2) - 0.04*Y(1) + 1e4*Y(2)*Y(3) + 3e7*Y(2)^2)
Y(1) + Y(2) + Y(3) - 1 ];
endfunction
[Y0_NEW,YP0_NEW] = decic (@robertson_dae, 0, [1; 0; 0], [1; 1; 0],
[-1e-4; 1; 0], [0; 0; 0]);
See also: Note: ode15i, Note: odeset.
-- : ODESTRUCT = odeset ()
-- : ODESTRUCT = odeset ("FIELD1", VALUE1, "FIELD2", VALUE2, ...)
-- : ODESTRUCT = odeset (OLDSTRUCT, "FIELD1", VALUE1, "FIELD2", VALUE2,
...)
-- : ODESTRUCT = odeset (OLDSTRUCT, NEWSTRUCT)
-- : odeset ()
Create or modify an ODE options structure.
When called with no input argument and one output argument, return
a new ODE options structure that contains all possible fields
initialized to their default values. If no output argument is
requested, display a list of the common ODE solver options along
with their default value.
If called with name-value input argument pairs "FIELD1", "VALUE1",
"FIELD2", "VALUE2", ... return a new ODE options structure with all
the most common option fields initialized, *and* set the values of
the fields "FIELD1", "FIELD2", ... to the values VALUE1, VALUE2,
....
If called with an input structure OLDSTRUCT then overwrite the
values of the options "FIELD1", "FIELD2", ... with new values
VALUE1, VALUE2, ... and return the modified structure.
When called with two input ODE options structures OLDSTRUCT and
NEWSTRUCT overwrite all values from the structure OLDSTRUCT with
new values from the structure NEWSTRUCT. Empty values in NEWSTRUCT
will not overwrite values in OLDSTRUCT.
The most commonly used ODE options, which are always assigned a
value by ‘odeset’, are the following:
AbsTol
Absolute error tolerance.
BDF
Use BDF formulas in implicit multistep methods. _Note_: This
option is not yet implemented.
Events
Event function. An event function must have the form ‘[value,
isterminal, direction] = my_events_f (t, y)’
InitialSlope
Consistent initial slope vector for DAE solvers.
InitialStep
Initial time step size.
Jacobian
Jacobian matrix, specified as a constant matrix or a function
of time and state.
JConstant
Specify whether the Jacobian is a constant matrix or depends
on the state.
JPattern
If the Jacobian matrix is sparse and non-constant but
maintains a constant sparsity pattern, specify the sparsity
pattern.
Mass
Mass matrix, specified as a constant matrix or a function of
time and state.
MassSingular
Specify whether the mass matrix is singular. Accepted values
include "yes", "no", "maybe".
MaxOrder
Maximum order of formula.
MaxStep
Maximum time step value.
MStateDependence
Specify whether the mass matrix depends on the state or only
on time.
MvPattern
If the mass matrix is sparse and non-constant but maintains a
constant sparsity pattern, specify the sparsity pattern.
_Note_: This option is not yet implemented.
NonNegative
Specify elements of the state vector that are expected to
remain non-negative during the simulation.
NormControl
Control error relative to the 2-norm of the solution, rather
than its absolute value.
OutputFcn
Function to monitor the state during the simulation. For the
form of the function to use see ‘odeplot’.
OutputSel
Indices of elements of the state vector to be passed to the
output monitoring function.
Refine
Specify whether output should be returned only at the end of
each time step or also at intermediate time instances. The
value should be a scalar indicating the number of equally
spaced time points to use within each timestep at which to
return output. _Note_: This option is not yet implemented.
RelTol
Relative error tolerance.
Stats
Print solver statistics after simulation.
Vectorized
Specify whether ‘odefun’ can be passed multiple values of the
state at once.
Field names that are not in the above list are also accepted and
added to the result structure.
See also: Note: odeget.
-- : VAL = odeget (ODE_OPT, FIELD)
-- : VAL = odeget (ODE_OPT, FIELD, DEFAULT)
Query the value of the property FIELD in the ODE options structure
ODE_OPT.
If called with two input arguments and the first input argument
ODE_OPT is an ODE option structure and the second input argument
FIELD is a string specifying an option name, then return the option
value VAL corresponding to FIELD from ODE_OPT.
If called with an optional third input argument, and FIELD is not
set in the structure ODE_OPT, then return the default value DEFAULT
instead.
See also: Note: odeset.
-- : STOP_SOLVE = odeplot (T, Y, FLAG)
Open a new figure window and plot the solution of an ode problem at
each time step during the integration.
The types and values of the input parameters T and Y depend on the
input FLAG that is of type string. Valid values of FLAG are:
‘"init"’
The input T must be a column vector of length 2 with the first
and last time step (‘[TFIRST TLAST]’. The input Y contains
the initial conditions for the ode problem (Y0).
‘""’
The input T must be a scalar double specifying the time for
which the solution in input Y was calculated.
‘"done"’
The inputs should be empty, but are ignored if they are
present.
‘odeplot’ always returns false, i.e., don’t stop the ode solver.
Example: solve an anonymous implementation of the "Van der Pol"
equation and display the results while solving.
fvdp = @(t,y) [y(2); (1 - y(1)^2) * y(2) - y(1)];
opt = odeset ("OutputFcn", @odeplot, "RelTol", 1e-6);
sol = ode45 (fvdp, [0 20], [2 0], opt);
Background Information: This function is called by an ode solver
function if it was specified in the "OutputFcn" property of an
options structure created with ‘odeset’. The ode solver will
initially call the function with the syntax ‘odeplot ([TFIRST,
TLAST], Y0, "init")’. The function initializes internal variables,
creates a new figure window, and sets the x limits of the plot.
Subsequently, at each time step during the integration the ode
solver calls ‘odeplot (T, Y, [])’. At the end of the solution the
ode solver calls ‘odeplot ([], [], "done")’ so that odeplot can
perform any clean-up actions required.
See also: Note: odeset, Note: odeget, Note:
ode23, Note: ode45.
automatically generated by info2www version 1.2.2.9