Getting Started with Differential Equations in Julia

In this example, we will solve the equation

on the time interval ] where . Here, is the current state variable, is our parameter variable (containing things like a reaction rate or the constant of gravity), and is the current time.

(In our example, we know by calculus that the solution to this equation is , but we will use DifferentialEquations.jl to solve this problem numerically, which is essential for problems where a symbolic solution is not known.)

The general workflow is to define a problem, solve the problem, and then analyze the solution. The full code for solving this problem is:

where the pieces are described below.

In this example, we will solve the Lorenz equations:

Defining your ODE function to be in-place updating can have performance benefits. What this means is that, instead of writing a function which outputs its solution, you write a function which updates a vector that is designated to hold the solution. By doing this, DifferentialEquations.jl’s solver packages are able to reduce the amount of array allocations and achieve better performance.

The way we do this is we simply write the output to the 1st input of the function. For example, our Lorenz equation problem would be defined by the function:

and then we can use this function in a problem:

Using the plot recipe tools defined on the plotting page, we can choose to do a 3D phase space plot between the different variables:

Note that the default plot for multidimensional systems is an overlay of each timeseries. We can plot the timeseries of just the second component using the variable choices interface once more:

Note that here “variable 0” corresponds to the independent variable (“time”).

Often, you want to explicitly have parameters associated with your differential equations. This can be used by things like parameter estimation routines. In this case, you use the p values via the syntax:

and then we add the parameters to the ODEProblem:

We can make our functions look nicer by doing a few tricks. For example:

Note that the type for the parameters p can be anything: you can use arrays, static arrays, named tuples, etc. to enclose your parameters in a way that is sensible for your problem.

Since the parameters exist within the function, functions defined in this manner can also be used for sensitivity analysis, parameter estimation routines, and bifurcation plotting. This makes DifferentialEquations.jl a full-stop solution for differential equation analysis which also achieves high performance.

Parameterized functions can also be used for building nonhomogeneous ordinary differential equations (these are also referred to as ODEs with nonzero right-hand sides). They are frequently used as models for dynamical systems with external (in general time-varying) inputs. As an example, consider a model of a pendulum consisting of a slender rod of length l and mass m:

where θ and ω are the angular deviation of the pendulum from the vertical (hanging) orientation and the angular rate, respectively, M is an external torque (developed, say, by a wind or a motor), and finally, g stands for gravitational acceleration.

Note how the external time-varying torque M is introduced as a parameter in the pendulum! function. Indeed, as a general principle the parameters can be any type; here we specify M as time-varying by representing it by a function, which is expressed by appending the dependence on time (t) to the name of the parameter.

Note also that, in contrast with the time-varying parameter, the (vector of) state variables u, which is generally also time-varying, is always used without the explicit dependence on time (t).

DifferentialEquations.jl can handle many different dependent variable types (generally, anything with a linear index should work!). So instead of solving a vector equation, let’s let u be a matrix! To do this, we simply need to have u0 be a matrix, and define f such that it takes in a matrix and outputs a matrix. We can define a matrix of linear ODEs as follows:

Here our ODE is on a 4x2 matrix, and the ODE is the linear system defined by multiplication by A. To solve the ODE, we do the same steps as before.

We can instead use the in-place form by using Julia’s in-place matrix multiplication function mul!:

Additionally, we can use non-traditional array types as well. For example, StaticArrays.jl offers immutable arrays which are stack-allocated, meaning that their usage does not require any (slow) heap-allocations that arrays normally have. This means that they can be used to solve the same problem as above, with the only change being the type for the initial condition and constants:

Note that the analysis tools generalize over to systems of equations as well.

still returns the solution at the fourth timestep. It also indexes into the array as well. The last value is the timestep, and the beginning values are for the component. This means

is the value of the 5th component (by linear indexing) at the 3rd timepoint, or

is the timeseries for the component, which is the 2nd row and 1 column.

Not everything can be covered in the tutorials. Instead, this tutorial will end by pointing you in the directions for the next steps.

One feature of DifferentialEquations.jl is that this pattern for solving equations is conserved across the different types of differential equations. Every equation has a problem type, a solution type, and the same solution handling (+ plotting) setup. Thus the solver and plotting commands in the Basics section applies to all sorts of equations, like stochastic differential equations and delay differential equations. Each of these different problem types are defined in the Problem Types section of the docs. Every associated solver algorithm is detailed in the Solver Algorithms section, sorted by problem type. The same steps for ODEs can then be used for the analysis of the solution.

In many cases, the common workflow only starts with solving the differential equation. Many common setups have built-in solutions in DifferentialEquations.jl. For example, check out the features for:

Many more are defined in the relevant sections of the docs. Please explore the rest of the documentation, including tutorials for getting started with other types of equations. In addition, to get help, please either file an issue at the main repository or come have an informal discussion at our Gitter chatroom.