**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.**

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 first-order 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))

`ode`

does
not accept multivariate expressions such as `y(x, t)`

.
It also does not accept `piecewise`

expressions.

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 higher-order ODEs, you can find explicit solutions only for special types of equations. For example, the following second-order 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 higher-order 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 first-order ordinary differential equation | that
can be represented as M(x, y) dx + N(x, y) dy =
0 where | ExactFirstOrder |

Exact second-order ordinary differential equation | , if a first integral turns this equation into a first-order 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: Unable to detect 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
first-order 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 3-D, 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.