Documentation

# dsolve

Solve system of differential equations

Support for character vector or string inputs will be removed in a future release. Instead, use `syms` to declare variables and replace inputs such as `dsolve('Dy = y')` with ```syms y(t); dsolve(diff(y,t) == y)```.

## Syntax

``S = dsolve(eqn)``
``S = dsolve(eqn,cond)``
``S = dsolve(___,Name,Value)``
``[y1,...,yN] = dsolve(___)``

## Description

example

````S = dsolve(eqn)` solves the differential equation `eqn`, where `eqn` is a symbolic equation. Use `diff` and `==` to represent differential equations. For example, `diff(y,x) == y` represents the equation dy/dx = y. Solve a system of differential equations by specifying `eqn` as a vector of those equations.```

example

````S = dsolve(eqn,cond)` solves `eqn` with the initial or boundary condition `cond`.```

example

````S = dsolve(___,Name,Value)` uses additional options specified by one or more `Name,Value` pair arguments.```

example

````[y1,...,yN] = dsolve(___)` assigns the solutions to the variables `y1,...,yN`.```

## Examples

collapse all

Solve the first-order differential equation $\frac{\mathit{dy}}{\mathit{dt}}=\mathit{ay}.$

Specify the first-order derivative by using `diff` and the equation by using ==. Then, solve the equation by using `dsolve`.

```syms y(t) a eqn = diff(y,t) == a*y; S = dsolve(eqn)```
`S = ${C}_{1} {\mathrm{e}}^{a t}$`

The solution includes a constant. To eliminate constants, see Solve Differential Equations with Conditions. For a full workflow, see Solving Partial Differential Equations.

Solve the second-order differential equation $\frac{{\mathit{d}}^{2}\mathit{y}}{{\mathit{dt}}^{2}}=\mathit{ay}.$

Specify the second-order derivative of y by using `diff(y,t,2)` and the equation by using `==`. Then, solve the equation by using `dsolve`.

```syms y(t) a eqn = diff(y,t,2) == a*y; ySol(t) = dsolve(eqn)```
`ySol(t) = ${C}_{1} {\mathrm{e}}^{-\sqrt{a} t}+{C}_{2} {\mathrm{e}}^{\sqrt{a} t}$`

Solve the first-order differential equation $\frac{\mathit{dy}}{\mathit{dt}}=\mathit{ay}$ with the initial condition $y\left(0\right)=5$.

Specify the initial condition as the second input to `dsolve` by using the `==` operator. Specifying condition eliminates arbitrary constants, such as `C1`, `C2`, `...`, from the solution.

```syms y(t) a eqn = diff(y,t) == a*y; cond = y(0) == 5; ySol(t) = dsolve(eqn,cond)```
`ySol(t) = $5 {\mathrm{e}}^{a t}$`

Next, solve the second-order differential equation $\frac{{\mathit{d}}^{2}\mathit{y}}{{\mathit{dt}}^{2}}={\mathit{a}}^{2}\mathit{y}$ with the initial conditions $y\left(0\right)=b$ and ${y}^{\prime }\left(0\right)=1$.

Specify the second initial condition by assigning `diff(y,t)` to `Dy` and then using `Dy(0) == 1`.

```syms y(t) a b eqn = diff(y,t,2) == a^2*y; Dy = diff(y,t); cond = [y(0)==b, Dy(0)==1]; ySol(t) = dsolve(eqn,cond)```
```ySol(t) =  $\frac{{\mathrm{e}}^{a t} \left(a b+1\right)}{2 a}+\frac{{\mathrm{e}}^{-a t} \left(a b-1\right)}{2 a}$```

This second-order differential equation has two specified conditions, so constants are eliminated from the solution. In general, to eliminate constants from the solution, the number of conditions must equal the order of the equation.

Solve the system of differential equations

`$\begin{array}{l}\frac{\mathit{dy}}{\mathit{dt}}=\mathit{z}\\ \frac{\mathit{dz}}{\mathit{dt}}=-\mathit{y}.\end{array}$`

Specify the system of equations as a vector. `dsolve` returns a structure containing the solutions.

```syms y(t) z(t) eqns = [diff(y,t) == z, diff(z,t) == -y]; S = dsolve(eqns)```
```S = struct with fields: z: [1x1 sym] y: [1x1 sym] ```

Access the solutions by addressing the elements of the structure.

`ySol(t) = S.y`
`ySol(t) = ${C}_{1} \mathrm{cos}\left(t\right)+{C}_{2} \mathrm{sin}\left(t\right)$`
`zSol(t) = S.z`
`zSol(t) = ${C}_{2} \mathrm{cos}\left(t\right)-{C}_{1} \mathrm{sin}\left(t\right)$`

When solving for multiple functions, `dsolve` returns a structure by default. Alternatively, you can assign solutions to functions or variables directly by explicitly specifying the outputs as a vector. `dsolve` sorts the outputs in alphabetical order using `symvar`.

Solve a system of differential equations and assign the outputs to functions.

```syms y(t) z(t) eqns = [diff(y,t)==z, diff(z,t)==-y]; [ySol(t),zSol(t)] = dsolve(eqns)```
`ySol(t) = ${C}_{1} \mathrm{cos}\left(t\right)+{C}_{2} \mathrm{sin}\left(t\right)$`
`zSol(t) = ${C}_{2} \mathrm{cos}\left(t\right)-{C}_{1} \mathrm{sin}\left(t\right)$`

If `dsolve` cannot solve a differential equation analytically, then it returns an empty symbolic array. You can solve the differential equation by using MATLAB® numerical solver, such as `ode45`. For more information, see Solve a Second-Order Differential Equation Numerically.

```syms y(x) eqn = diff(y, 2) == (1 - y^2)*diff(y) - y; S = dsolve(eqn)```
```Warning: Unable to find explicit solution. ```
``` S = [ empty sym ] ```

Solve the differential equation $\frac{\mathit{dy}}{\mathit{dt}}=\frac{\mathit{a}}{\sqrt{\mathit{y}}}+\mathit{y}$ with condition $y\left(a\right)=1$. By default, `dsolve` applies simplifications that are not generally correct, but produce simpler solutions. For more details, see Algorithms.

```syms a y(t) eqn = diff(y) == a/sqrt(y) + y; cond = y(a) == 1; ySimplified = dsolve(eqn, cond)```
```ySimplified =  ${\left({\mathrm{e}}^{\frac{3 t}{2}-\frac{3 a}{2}+\mathrm{log}\left(a+1\right)}-a\right)}^{2/3}$```

To return the solutions that include all possible values of the parameter $a$, turn off simplifications by setting `'IgnoreAnalyticConstraints'` to `false`.

`yNotSimplified = dsolve(eqn,cond,'IgnoreAnalyticConstraints',false)`
```yNotSimplified =  ```

Solve the differential equation $\frac{\mathit{dy}}{\mathit{dx}}=\frac{1}{{\mathit{x}}^{2}}{\mathit{e}}^{-\frac{1}{\mathit{x}}}$ without specifying the initial condition.

```syms y(x) eqn = diff(y) == exp(-1/x)/x^2; ySol(x) = dsolve(eqn)```
```ySol(x) =  ${C}_{3}+{\mathrm{e}}^{-\frac{1}{x}}$```

To eliminate constants from the solution, specify the initial condition $\mathit{y}\left(0\right)=1.$

```cond = y(0) == 1; S = dsolve(eqn,cond)```
```S =  ${\mathrm{e}}^{-\frac{1}{x}}+1$```

The function ${\mathit{e}}^{-\frac{1}{\mathit{x}}}$ in the solution `ySol(x)` has different one-sided limits at $x=0$. The function has a right-side limit, $\underset{\mathit{x}\to {0}^{+}}{\mathrm{lim}}\text{\hspace{0.17em}}{\mathit{e}}^{-\frac{1}{\mathit{x}}}=0$, but it has undefined left-side limit, $\underset{\mathit{x}\to {0}^{-}}{\mathrm{lim}}\text{\hspace{0.17em}}{\mathit{e}}^{-\frac{1}{\mathit{x}}}=\infty$.

When you specify the condition `y(x0)` for a function with different one-sided limits at `x0`, `dsolve` treats the condition as a limit from the right $\mathrm{lim}\text{\hspace{0.17em}}\mathit{x}\to {\mathit{x}}_{0}^{+}$.

## Input Arguments

collapse all

Differential equation or system of equations, specified as a symbolic equation or a vector of symbolic equations.

Specify a differential equation by using the `==` operator. In the equation, represent differentiation by using `diff`. For example, `diff(y,x)` differentiates the symbolic function `y(x)` with respect to `x`. Create the symbolic function `y(x)` by using `syms` and solve the equation ```d2y(x)/dx2 = x*y(x)``` using `dsolve`.

```syms y(x) dsolve(diff(y,x,2) == x*y)```

Specify a system of differential equations by using a vector of equations, as in `dsolve([diff(y,t) == z, diff(z,t) == -y])`.

Initial or boundary condition, specified as a symbolic equation or vector of symbolic equations.

When a condition contains a derivative, represent the derivative with `diff`. Assign the `diff` call to a variable and use the variable to specify the condition. For example, see Solve Differential Equations with Conditions.

Specify multiple conditions by using a vector of equations. If the number of conditions is less than the number of dependent variables, the solutions contain the arbitrary constants `C1`, `C2`,`...`.

### Name-Value Pair Arguments

Specify optional comma-separated pairs of `Name,Value` arguments. `Name` is the argument name and `Value` is the corresponding value. `Name` must appear inside quotes. You can specify several name and value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.

Example: `'IgnoreAnalyticConstraints',false` does not apply internal simplifications.

Option to use internal simplifications, specified as `true` or `false`.

By default, the solver applies simplifications while solving the differential equation. These simplifications might not be generally valid. Therefore, by default, the solver does not guarantee the completeness of results. If `'IgnoreAnalyticConstraints'` is `true`, always verify results returned by the `dsolve` function. For more details, see Algorithms.

To solve ordinary differential equations without these simplifications, set `'IgnoreAnalyticConstraints'` to `false`. Results obtained with `'IgnoreAnalyticConstraints'` set to `false` are correct for all values of the arguments. For certain equations, `dsolve` might not return an explicit solution if you set `'IgnoreAnalyticConstraints'` to `false`.

Maximum degree of polynomial equations for which the solver uses explicit formulas, specified as a positive integer smaller than 5. `dsolve` does not use explicit formulas when solving polynomial equations of degrees larger than `'MaxDegree'`.

## Output Arguments

collapse all

Solutions of differential equation, returned as a symbolic expression or a vector of symbolic expressions. The size of `S` is the number of solutions.

Variables storing solutions of differential equations, returned as a vector of symbolic variables. The number of output variables must equal the number of dependent variables in a system of equations. `dsolve` sorts the dependent variables alphabetically, and then assigns the solutions for the variables to output variables or symbolic arrays.

## Tips

• If `dsolve` cannot find a closed-form (explicit) solution, it attempts to find an implicit solution. When `dsolve` returns an implicit solution, it issues this warning:

```Warning: Explicit solution could not be found; implicit solution returned.```
• If `dsolve` cannot find an explicit or implicit solution, then it issues a warning and returns the empty `sym`. In this case, try to find a numeric solution using the MATLAB® `ode23` or `ode45` function. Sometimes, the output is an equivalent lower-order differential equation or an integral.

• `dsolve` does not always return complete solutions even if `'IgnoreAnalyticConstraints'` is `false`.

• If `dsolve` returns a function that has different one-sided limits at `x0` and you specify the condition `y(x0)`, then `dsolve` treats the condition as a limit from the right, .

## Algorithms

If you do not set `'IgnoreAnalyticConstraints'` to `false`, then `dsolve` applies these rules while solving the equation:

• log(a) + log(b) = log(a·b) for all values of a and b. In particular, the following equality is applied for all values of a, b, and c:

(a·b)c = ac·bc.

• log(ab) = b·log(a) for all values of a and b. In particular, the following equality is applied for all values of a, b, and c:

(ab)c = ab·c.

• If f and g are standard mathematical functions and f(g(x)) = x for all small positive numbers, f(g(x)) = x is assumed to be valid for all complex x. In particular:

• log(ex) = x

• asin(sin(x)) = x, acos(cos(x)) = x, atan(tan(x)) = x

• asinh(sinh(x)) = x, acosh(cosh(x)) = x, atanh(tanh(x)) = x

• Wk(x·ex) = x for all branch indices k of the Lambert W function.

• The solver can multiply both sides of an equation by any expression except `0`.

• The solutions of polynomial equations must be complete.

## Compatibility Considerations

expand all

Warns starting in R2019b