Edit: This post is very old. See this post for more up-to-date information.
Differential equations are ubiquitous throughout mathematics and the sciences. In fact, I myself have studied various forms of differential equations stemming from fields including biology, chemistry, economics, and climatology. What was interesting is that, although many different people are using differential equations for many different things, pretty much everyone wants the same thing: to quickly solve differential equations in their various forms, and make some pretty plots to describe what happened.
The goal of DifferentialEquations.jl is to do exactly that: to make it easy solve differential equations with the latest and greatest algorithms, and put out a pretty plot. The core idea behind DifferentialEquations.jl is that, while it is easy to describe a differential equation, they have such diverse behavior that experts have spent over a century compiling different ways to think about and handle differential equations. Most users will want to just brush past all of the talk about which algorithms simply ask: "I have this kind of differential equation. What does the solution look like?"
DifferentialEquations.jl's User Interface
To answer that question, the user should just have to say what their problem is, tell the computer to solve it, and then tell the computer to plot it. In DifferentialEquations.jl, we use exactly those terms. Let's look at an Ordinary Differential Equation (ODE): the linear ODE . It is described as the function
To use DifferentialEquations.jl, you first have to tell the computer what kind of problem you have, and what your data is for the problem. Recall the general ordinary differential equation is of the form
and initial condition , so in this case, we have an ODE with data and . DifferentialEquations.jl is designed as a software for a high-level language, Julia. There are many reasons for this choice, but the one large reason is its type system and multiple dispatch. For our example, we tell the machine what type of problem we have by building a DEProblem type. The code looks like this:
using DifferentialEquations alpha = 0.5 #Setting alpha to 1/2 f(y,t) = alpha*y u0 = 1.5 prob = ODEProblem(f,u0)
where prob contains everything about our problem. You can then tell the computer to solve it and give you a plot by, well, solve and plot:
timespan = [0,1] # Solve from time = 0 to time = 1 sol = solve(prob,timespan) # Solves the ODE plot(sol) # Plots the solution using Plots.jl
And that's the key idea: the user should simply have to tell the program what the problem is, and the program should handle the details. That doesn't mean that the user won't have access to to all of the details. For example, we can control the solver and plotters in more detail, using something like
sol = solve(prob,alg=:RK4) # Unrolled and optimzed RK4 plot(sol,lw=3) # All of the Plots.jl attributes are available
However, in many cases a user may approach the problem for which they don't necessarily know anything about the algorithms involved in approximating the problem, and so obfuscating the API with these names is simply confusing. One place where this occurs is solving stochastic differential equations (SDEs). These have been recently growing in popularity in many of the sciences (especially systems biology) due to their added realism and their necessity when modeling rare and random phenomena. In DifferentialEquations.jl, you can get started by simply knowing that an SDE problem is defined by the functions and in the form
with initial condition , and so the steps for defining and solving the linear SDE is
g(u,t) = 0.3u prob = SDEProblem(f,g,u0) sol = solve(prob,timespan) plot(sol)
If you wish to dig into the manual, you will see that the default solver that is used is a Rossler-SRI type of method and will (soon) have adaptivity which is complex enough to be a numerical analysis and scientific computing research project. And you can dig into the manual to find out how to switch to different solvers, but the key idea is that you don't have to. Everything is simply about defining a problem, and asking for solutions and plots.
And that's it. For more about the API, take a look at the documentation or the tutorial IJulia notebooks. What I want to discuss is why I believe this is the right choice, where we are, and where we can go with it.
What exactly does that give us?
Julia was created to solve the many-language problem in scientific computing. Before people would have to write out the inner loops as C/Fortran, and bind it to a scripting language that was never designed with performance in mind. Julia has done extremely well as solving this problem via multiple-dispatch. Multiple dispatch is not just about ease of use, but it is also the core of what allows Julia to be fast . From a quote I am stealing from IRC: "Julia: come for the fast loops, stay for the type-system".
In my view, the many-language problem always had an uglier cousin: the many-API problem. Every package has its own way of interacting with the user, and it becomes a burden to remember how all of them work. However, in Julia there seems to be a beautiful emergence of packages which solve the many-API problem via Julia's multiple-dispatch and metaprogramming functionalities. Take for example Plots.jl. There are many different plotting packages in Julia. However, through Plots.jl, you can plot onto any "backend" (other plotting package) using just one API. You can mix and match plotting in PyPlot (matplotlib), GR, Plotly, and unicode. It's all the same commands. Another example of this is JuMP. Its core idea is solver independence: you take your optimization problem, define the model in JuMP's lingo, and then plug into many different solvers all by flipping a switch.
DifferentialEquations.jl is extending this idea to the realm of differential equations. By using the keyword `alg=:ode45`, the solver can call functions from ODE.jl. And changing it to `alg=:dopri5`, DifferentialEquations.jl will solve your ODE problem using the coveted dopri5 Fortran software. The complexity of learning and understanding many different APIs is no longer a requirement for trying different algorithms.
But why "Differential Equations"? Isn't that broad?
Sure, there are packages for solving various types of differential equations, all specializing in one little part. But when I was beginning my PhD, quickly found that these packages were missing something. The different types of differential equations that we encounter are not different but many times embody the same problem: a PDE when discretized is a system of ODEs, the probability distribution of evolving SDEs is a PDE (a form of the Heat Equation), and all of the tools that they use to get good performance are the same. Indeed, many contemporary research questions can be boiled down to addressing the question: what happens if we change the type of differential equation? What happens if we add noise to our ODEs which describe population dispersal? What happens if we add to our model that RNA production is reading a delayed signal? Could we make this high-dimensional PDE computationally feasible via a Monte Carlo experiment combined with Feynman-Kac's theorem?
Yet, our differential equations libraries are separate. Our PDEs are kept separate from our SDEs, while our delay equations hang out in their own world. Mixing and matching solvers requires learning complex APIs, usually large C/Fortran libraries with opaque function names. That is what DifferentialEquations.jl is looking to solve. I am building DifferentialEquations.jl as a hub for differential equations, the general sense of the term.
If you have defined an SDE problem, then via the Forward Kolmorogov equation there is a PDE associated to the SDE. In many cases like the Black-Scholes model, both the SDE and the PDE are canonical ways of looking at the same problem. The solver should translate between them, and the solver should handle both types of differential equations. With one API and the functionality for these contained within the same package, no longer are they separate entities to handle computationally.
Where are we currently?
DifferentialEquations.jl is still very young. Indeed, the project only started a few months ago, and during that time period I was taking 6 courses. However, the package already has a strong core, including
- Most of the standard ODE, SDE, and PDE (Heat and Poisson) solvers.
- Plot recipes for all the basic types.
- Tests for convergence of every algorithm.
- Extensive documentation and tutorials.
In fact, there are already a lot of features which are unique to DifferentialEquations.jl:
- Implementations of Feagin's Order 10, 12, and 14 Runge-Kutta methods.
- Compatibility with Julia-defined number types. This has been tested to work with Bigs, DecFP, and ArbFloats, and is actively being tested with ArbReals and DoubleDouble.
- Wrappers to ODE.jl and ODEInterface, giving you instant access to tons of different solver methods just by changing the `alg` keyword.
- State-of-the-art stochastic differential equation solvers. As noted before, implemented are results from recent papers, and many other algorithms are waiting on a private branch until papers are published.
- Finite element solvers for some common stochastic PDEs, including the Reaction-Diffusion equation used to describe Turing Morphogenesis.
- An algorithm design and testing suite.
You may have been thinking, "but I am a numerical analyst. How could this program help me?". DifferentialEquations.jl has a bunch of functionalities for quickly designing and testing algorithms. All of the DEProblems allow for one to give them the analytical solution, and the solvers will then automatically calculate the errors. Thus by using some simple macros, one can define new algorithms in just a few lines of code, test the convergence, benchmark times, and have the algorithm available as an `alg` option in no time (note: all of the ODE solvers were written in one morning!). Thus it is easy to define the loop, and the rest of the functionality will come by default. It's both a great way to test algorithms, and share algorithms. Contributing will both help you and DifferentialEquations.jl!.
Where are we going?
I have big plans for DifferentialEquations.jl. For example:
- I will be rolling out an efficiency testing suite so that one could just specify the algorithms you'd like to solve a problem, and along what convergence axis (i.e. choose a few s, or along changing tolerances), and it will output comparisons of the computational efficiencies and make some plots. It will be similar in functionality to the ConvergenceSimulation suite.
- Finite difference methods for Heat and Poisson equation. These are long overdue for the research I do.
- Changing the tableaus in ODEs and SDEs to StaticArrays so they are stack allocated. This has already been tested and works well on v0.5.
- Higher-order methods for parabolic SPDEs (a research project with promising results!).
- Blazing fast adaptivity for SDEs. (Once the paper I have submitted for it is published, it will be available. It's already implemented!)
- High-stability high order methods for SDEs (another research project).
- Parallel methods. I have already implemented parallel (Xeon Phi) solvers and described them in previous blog posts. They simply need to be integrated into DifferentialEquations.jl. I would like to have native GPU solvers as well.
- Delay and algebraic differential equations.
- Wrapping more popular solvers. I'd like to add Sundials, LSODE, and PetsC to the list.
- A web interface via Escher.jl to define DEProblems and get the solution plots. I am looking to have this hosted as an XSEDE Gateway.
If you'd like to influence where this project is going, please file an issue on the Github repository. I am always open for suggestions.
I hope this gives you a good idea on what my plans are for DifferentialEquations.jl. Check out the documentation and give the package a whirl!