numeric
::ode2vectorfield
Convert an ode system to vectorfield notation
MuPAD® notebooks will be removed in a future release. Use MATLAB® live scripts instead.
MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.
numeric::ode2vectorfield(IVP
, fields
)
numeric::ode2vectorfield
converts a system
of ordinary differential equations of arbitrary order to a vector
field representation suitable for the numerical ODE solver numeric::odesolve2
.
numeric::ode2vectorfield
is a utility function
to generate input parameters for the numerical ODE solver numeric::odesolve2
.
This solver requires a procedure representing the vectorfield f(t, Y) of
a first order system of differential equations (dynamic system) and
initial data Y_{0} = Y(t_{0}).
Given an initial value problem IVP
consisting of
(possibly higher order) differential expressions together with initial
conditions, numeric::ode2vectorfield
converts the
higher order equations to an equivalent system of first order ODEs
and returns the input parameters for numeric::odesolve2
.
Higherorder differential equations can always be represented as an equivalent dynamic system with some vector Y. E.g., the nth order equation
may be written as the first order system
for the vector .
The input list fields
correponds to the vector Y.
It must be a complete specification of all functions
and their derivatives through but not including the highest
derivates of the unknown functions. E.g., for the second
order differential equation ,
the appropriate list of unknown fields is .
The differential equations are
of second order in y and
of first order in z.
Hence, the appropriate list of unknown fields is [y(t), y'(t),
z(t)]
.
The ordering of the fields in list
determines
the ordering of the components of the list that the numerical solver
produces as the solution vector. Cf. Example 2.
The differential equations must be linear in the highest derivatives of the unknown functions involved. E.g., the ODE is not admitted. However, equations such as are accepted and converted to .
A complete specification of initial conditions
must be contained in IVP
: for each component in list
,
an initial value must be provided. The initial conditions may be specified
by linear equations which will be solved for the initial values of
the unknown fields automatically. E.g., for fields = [y(t),
y'(t), z(t)]
, initial conditions may be specified explicitly
by y(t_{0}) = 1
, y'(t_0)
= 2
, z(t_{0}) = 3
,
say, or via linear equations such as y(t_0) + z(t_0) = y'(t_0)
, y(t_{0})
= z(t_{0})
, z(t_{0})
= 2 y(t_{0})
. Cf. Example 3.
The differential equations, the initial ‘time’ t_{0}
,
and the initial conditions may involve symbolic parameters. However,
such parameters must evaluate to numerical objects, when the sequence
returned by numeric::ode2vectorfield
is passed
to the numerical solver.
The vectorfield procedure f
and the initial
values Y_{0}
returned by numeric::ode2vectorfield
can
also be used by the functions numeric::odesolve
, plot::Ode2d
, plot::Ode3d
. Cf. Example 3.
numeric::ode2vectorfield
and numeric::odeToVectorField
are
equivalent.
We consider the initial value problem
.
The solver numeric::odesolve2
requires
the procedure f:
for
the 1dimensional vector Y =
[y(t)] specified
by fields
. The utility numeric::ode2vectorfield
accepts
a more convenient representation via arithmetical expressions:
IVP := {y'(t) = t*sin(y(t)), y(t0) = y0}: fields := [y(t)]: IVP := numeric::ode2vectorfield(IVP, fields)
This sequence may be passed to the numerical solver which returns a procedure representing the numerical solution:
t0 := 0: y0 := 1: Y := numeric::odesolve2(IVP)
Calling the numerical solution Y
invokes
the numerical integration from the initial ‘time’ t_{0} =
0 to the ‘time’ specified in the
call to Y
:
Y(0), Y(1), Y(2), Y(3)
delete IVP, fields, Y:
We consider the second order initial value problem
.
The corresponding vectorfield representation involves the vector specified
by fields
:
IVP := {y''(t) = t*sin(y(t)), y(0) = 1, y'(0) = 0}: fields := [y(t), y'(t)]: numeric::ode2vectorfield(IVP, fields)
This sequence is accepted by numeric::odesolve2
. The numerical solution Y
returns
lists representing the components of the vector specified by fields
:
Y := numeric::odesolve2(%): Y(5)
With a reordering of the unknown fields, the numerical solver returns the solution vector with rearranged components:
fields := [y'(t), y(t)]: Y := numeric::odesolve2(numeric::ode2vectorfield(IVP, fields)): Y(5)
delete IVP, fields, Y:
The following IVP involves the unknown fields u(t), v(t), w(t).
Since it is of second order in u,
of first order in v and
of third order in w,
the list of unknowns [y(t), y'(t), v(t), w(t), w'(t), w''(t)]
is
appropriate:
IVP := {u''(t)  u(t)*v'(t) = exp(t)*v'(t), v'(t) = w''(t), u'(t)*w'''(t) = t + u''(t), u(PI) = 3, u'(PI) = 1, v(PI) = 0, w(PI) = w'(PI), w'(PI) = 2  w(PI), w''(PI) = 3*w(PI)}: fields := [u(t), u'(t), v(t), w(t), w'(t), w''(t)]: ivp := numeric::ode2vectorfield(IVP, fields)
Y := numeric::odesolve2(ivp): Y(5)
We plot the components v, w, and of the solution vector:
plotfunc2d(Y(t)[3], Y(t)[4], Y(t)[6], t = PI .. 5, Colors = [RGB::Red, RGB::Green, RGB::Blue]):
Alternatively, we use the vectorfield procedure ivp[1]
and
the initial conditions ivp[3]
as input parameters
for plot::Ode2d
:
plot(plot::Ode2d([PI + i*(5  PI)/30 $ i = 0..30], ivp[1], ivp[3], [(t, Y) > [t, Y[3]], Color = RGB::Red], [(t, Y) > [t, Y[4]], Color = RGB::Green], [(t, Y) > [t, Y[6]], Color = RGB::Blue])):
delete IVP, fields, ivp, Y:

The initial value problem: a list or a set of equations involving univariate function calls y_{1}(t), y_{2}(t) etc.
and derivates , ,
…, , etc.
The differential equations must be quasilinear: the highest derivative
of each of the dependent functions y_{1}(t), y_{2}(t) etc.
must enter the equations linearly. 

The vector of the dynamical system equivalent to 
Sequence f, t_{0}, Y_{0}
.
These data represent the dynamical system with
the initial condition Y(t_{0})
= Y_{0} equivalent
to IVP
. The vectorfield f:
is
a procedure, t_{0}
is
a numerical expression representing the initial ‘time’,
and Y_{0}
is a list of numerical
expressions representing the components of the initial vector Y_{0}.