MuPAD® notebooks are not recommended. 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.
An ordinary differential equation (ODE) contains derivatives
of dependent variables with respect to the only independent variable.
If y
is a dependent variable and x
is
an independent variable, the solution of an ODE is an expression y(x)
.
The order of the derivative of a dependent variable defines the order
of an ODE.
The solution of a single explicit firstorder ODE can always
be computed by integration, provided the solution exists. To define
an ordinary differential equation, use the ode
command:
o := ode(y'(x) = y(x)^2, y(x))
Note:

Now use the general solve to solve this equation:
solve(o)
Alternatively, you can call the ODE solver directly:
ode::solve(y'(x) = y(x)^2, y(x))
The general solutions of ODEs contain arbitrary constants of
integration. The solver generates the constants of integration using
the format of an uppercase letter C followed by an automatically generated
number. For example, it generates C1
, C2
,
and so on.
For higherorder ODEs, you can find explicit solutions only for special types of equations. For example, the following secondorder equation has a solution in terms of elementary functions:
ode::solve(y''(x) = y(x), y(x))
The solver introduces the solution of the following equation in terms of the Bessel functions. MuPAD^{®} uses standard mathematical notations for Bessel and other special functions:
ode::solve(y''(x) = y'(x) + y(x)*exp(x), y(x))
If you have a second or higherorder ODE, nonlinear ODE, or a system of ODEs, a symbolic solution does not always exist:
ode::solve(y''(x) = y'(x)^2 + y(x)*exp(x), y(x))
For ODEs that cannot be solved symbolically, try using numeric solvers.
Many problems in engineering and physics involve solving differential equations with initial conditions or boundary conditions or both. To specify initial or boundary conditions, create a set containing an equation and conditions. For example, state the following initial value problem by defining an ODE with initial conditions:
IVP := ode({y''(x) = y(x), y(0) = 5, y'(0) = 1}, y(x))
When you solve an ODE with initial or boundary conditions, the solver adjusts the integration constants to fit these conditions:
solve(IVP)
The following equation has both initial and boundary conditions:
ode::solve({y'''(x) = y(x), y(0) = 0, y(5) = 1, y'(0) = 0}, y(x))
Each independent condition removes one integration constant:
ode::solve({y'''(x) = y'(x)}, y(x))
ode::solve({y'''(x) = y'(x), y(0) = 0}, y(x))
ode::solve({y'''(x) = y'(x), y(0) = 0, y(1) = 1}, y(x))
ode::solve({y'''(x)=y'(x), y(0)=0, y(1)=1, y'(0)=1/2}, y(x))
Suppose, the equation you want to solve belongs to the Clairaut type:
o:= ode(y(x) = x*y'(x) + y'(x)^3, y(x)): solve(o)
The solver recognizes the type of the equation and applies the
algorithm for solving Clairaut equations. To improve performance,
call the solver with the option Type = Clairaut
:
solve(o, Type = Clairaut)
The solver tries to recognize and tries to solve the following classes of ODEs.
Type  Equation  ODE Solver Option 

Abel differential equation  Abel  
Bernoulli differential equation  where n ≠ 0 and n ≠ 1  Bernoulli 
Chini differential equation  Chini  
Clairaut differential equation  Clairaut  
Exact firstorder ordinary differential equation  that can be represented as M(x, y) dx + N(x, y) dy = 0 where  ExactFirstOrder 
Exact secondorder ordinary differential equation  , if a first integral turns this equation into a firstorder ODE  ExactSecondOrder 
Linear homogeneous ordinary differential equation  Dy = 0 , where D is a
linear differential operator  Homogeneous 
Lagrange differential equation  Lagrange  
Riccati differential equation  Riccati 
If the solver cannot identify the equation with the type you
indicated, it issues a warning and returns the special value FAIL
:
ode::solve(y'(x) + y(x) = x, y(x), Type = Homogeneous)
Warning: Cannot detect the homogeneous ODE. [ode::homogeneous]
To solve a system of differential equations, specify the system as a set of equations:
s := {y'(x) = z(x), z'(x) = y(x) + 2*z(x)}:
Call the ode::solve
function
specifying the set of functions {y(x), z(x)} for
which you want to solve the system:
ode::solve(s, {y(x), z(x)})
Now, suppose the system of differential equations appears in
a matrix form. For example, define the system
,
where A
, B
, and Y
represent
the following matrices:
Y:= matrix([x(t), y(t)]): A:= matrix([[1, 2], [1, 1]]): B:= matrix([1, t]):
The ode::solve
function
does not accept matrices. To be able to use this solver, extract the
components of the matrix and include them in a set. Use the op
function to extract
the equations from the matrix. Then, use the braces to create a set
of the equations. You can omit the right sides of equations, in which
case MuPAD assumes them to be 0:
s := {op(diff(Y, t)  A*Y  B)}
Now, specify the set of functions {x(t), y(t)} for which you want to solve the system. Solve the system:
ode::solve(s, {x(t), y(t)})
If you are solving several similar systems of ordinary differential
equations in a matrix form, create your own solver for these systems,
and then use it as a shortcut. The solver for such systems must be
a function that accepts matrices as input arguments, and then performs
all required steps. For example, create a solver for a system of the
firstorder linear differential equations in a matrix form
,
where the components of functions depend on the variable t
:
solveLinearSystem := (A, B, Y) > solve(ode({op(diff(Y, t)  A*Y  B)}, {op(Y)})):
The solveLinearSystem
function accepts matrices
as input parameters, creates a matrix of equations, extracts these
equations to a set, and solves the system:
Y:= matrix([x(t), y(t)]): A:= matrix([[1, 2], [3, 1]]): B:= matrix([2, t]): solveLinearSystem(A, B, Y)
Suppose you want to solve the following equation. The solver returns the results as a set even if the set contains only one element:
f := ode::solve({y''(x) = x*y'(x), y(0) = 0, y'(0) = 1/3}, y(x))
The plotting functions in MuPAD do not accept sets. To
plot the solution, access the elements of a solution set using square
brackets or the op
command:
plotfunc2d(f[1], x = 3..3)
If you have more than one element of a solution set, you can access a particular element. For example, pick the second element of the solution set for the system of ODEs:
f := ode::solve( {y'(x) = z(x), z'(x) = y(x) + 2*z(x), y(0) = 0, z(0) = 1}, {y(x), z(x)})
The solver returns results for a system as a set that contains
a list. To open the set and access the list, use square brackets or
the op
command.
To access a particular entry of this list, use square brackets:
f[1][2]; op(f)[2]
To access the right side of the equation, use square brackets
or the rhs
command:
f[1][2][2]; rhs(f[1][2])
Plot this solution:
plotfunc2d(f[1][2][2], x = 1..1)
To plot a solution of the system of ODEs in 3D, use the plot::Curve3d
command:
solution := plot::Curve3d([x, f[1][2][2], f[1][1][2]], x = 2..2, GridVisible): plot(solution)
MuPAD provides the functions plot::Ode2d
and plot::Ode3d
for visualizing solutions
of ODEs. Also, you can plot a vector field associated with an ODE.
For all graphic capabilities available in MuPAD, see Graphics
and Animations.