DifferentialEquations.jl 3.2 is just a nice feature update. This hits a few long requested features.
Integrators, Callbacks, and Events with Sundials
The callbacks, both
ContinuousCallback, are now able
to be used with the Sundials.jl solvers. This includes
IDA, the DAE solver, as
well. This was one of the most requested features for a long time and, well, it’s
tstops works with Sundials as well, meaning that all of the tricks
used for building complex control schemes can now work with Sundials.jl.
Additionally, the integrator interface for controlling Sundials via an iterator
exists as well. Note that not all of the integrator interface functions are
implemented right now, but at this point implementing most of them is quite
simple. So please feel free to open feature requests and we can tackle them as
Sundials.jl is now very well integrated into the DiffEq ecosystem. It’s compatible
with almost every option. The things it’s not compatible with, such as arbitrary
number types, do not seem to fit into the main purposes of its schemes anyways.
The multistep schemes from this library are most efficient in cases where the
f is expensive or the number of ODEs is large. In these cases, arbitrary
precision is infeasible anyways. Thus, since Sundials is a very well-optimized
library, I am putting the development of a native Julia multistep method on
the backburner. Instead, I think the next goals in this domain should be
to finish getting full compatibility of Sundials with the common interface, and
that includes the ability to pass preconditioners, user-defined banded Jacobians,
and ARKODE. Getting those setup with our simple interfaces will make powerful
PDE solving tools and there’s no reason to double our efforts here.
Callbacks and Events with ODEInterface (and some performance improvements)
In the same vein as above, ODEInterface.jl’s common interface bindings are now
compatible with our callback interfaces. This library is now controlled at a
much lower level where we handle its stepping through its output functions.
There’s a few other things which are gained from this. First of all, we more
directly save information that we want, so this actually gives a performance
gain. Secondly, this allowed us to use
saveat with the intermediate dense
output. Thus while the solution given to the user only has a linear dense output
due to restrictions of the library, within each step
are able to make use of the libraries internal higher order interpolation.
The end result is that these functions are very compatible with the common
interface now. There are two big exceptions. This library will not be compatible
tstops, and it cannot have the full
integrator interface (i.e. instead
init). This is due to how the core integration functions
are written in FORTRAN. However, instead of using
tstops with a
one can always make use of a
ContinuousCallback, so it’s not terrible.
But this means that useful algorithms like
seulex now have all of the
tools to be used with event handling and the like. Thus, for the same reasons
as with Sundials, remaking
radau into a native Julia version is now lower
on the priority list. Instead, getting this library setup with user-defined
banded Jacobians would satisfy most users in this department, so I plan on
hitting that up soon and then tackling other areas.
DiffEqBenchmarks.jl got a huge update. The nonstiff ODE problems now showcase more algorithms like lsoda and ddeabm. There are a lot of new stiff ODE test problems and they cover a wide range of algorithms. There’s new tooling which allows for generating work-precision plots of stochastic differential equations without analytical solutions (for both strong and weak error) which is showing some really interesting results that showcase the efficiency of high order adaptive methods.
Arrays of Static Arrays
Nested arrays can be a natural way to represent a problem. The
can now handle these nested arrays of static arrays. One user reported a speedup
of 4x by using this to represent their equation.
New Wrapped Libraries
We welcome Bridge.jl and GeometericIntegrators.jl wrappers to the DiffEq-sphere. Bridge.jl is a library for stochastic calculus and it has some nice out-of-place fixed timestep solvers for stochastic differential equations. GeometericIntegrators.jl is a library of fixed timestep solvers which will likely be focusing on geometric and conservative algorithms. Following the theme of not doubling efforts across the Julia ecosystem, these wrappers expand our focus with less effort.
The “in development” list has falling sharply. First of all, many things have finished. Other things are being left for Google Summer of Code. But mainly, the increased compatibility of wrapped packages allows us to shift focus. While there would still be advantages of a pure-Julia BDF or Radau method, the advantages, now that these are compatible with even more advanced features like event handling, are minimal. Thus these have been shifted to a lower priority, allowing us to shift our focus.
Thus the main current “in development” list is:
- IMEX and Exponential Integrators
- Improved jump methods (tau-leaping)
- Stiff SDE solvers
- Banded and sparse Jacobian support