# ODE solvers¤

Term structure

The type of solver chosen determines how the terms argument of diffeqsolve should be laid out. Most of them demand that it should be a single AbstractTerm. But for example diffrax.SemiImplicitEuler demands that it be a 2-tuple (AbstractTerm, AbstractTerm), to represent the two vector fields that solver uses.

If it is different from this default, then you can find the appropriate structure documented below, and available programmatically under <solver>.term_structure.

### Explicit Runge--Kutta (ERK) methods¤

These methods are suitable for most problems.

####  diffrax.Euler (AbstractItoSolver) ¤

Euler's method.

1st order explicit Runge--Kutta method. Does not support adaptive step sizing. Uses 1 stage. Uses 1st order local linear interpolation for dense/ts output.

When used to solve SDEs, converges to the Itô solution.

####  diffrax.Heun (AbstractERK, AbstractStratonovichSolver) ¤

Heun's method.

2nd order explicit Runge--Kutta method. Has an embedded Euler method for adaptive step sizing. Uses 2 stages. Uses 2nd-order Hermite interpolation for dense/ts output.

Also sometimes known as either the "improved Euler method", "modified Euler method" or "explicit trapezoidal rule".

Should not be confused with Heun's third order method, which is a different (higher order) method occasionally also just referred to as "Heun's method".

When used to solve SDEs, converges to the Stratonovich solution.

####  diffrax.Midpoint (AbstractERK, AbstractStratonovichSolver) ¤

Midpoint method.

2nd order explicit Runge--Kutta method. Has an embedded Euler method for adaptive step sizing. Uses 2 stages. Uses 2nd order Hermite interpolation for dense/ts output.

Also sometimes known as the "modified Euler method".

When used to solve SDEs, converges to the Stratonovich solution.

####  diffrax.Ralston (AbstractERK, AbstractStratonovichSolver) ¤

Ralston's method.

2nd order explicit Runge--Kutta method. Has an embedded Euler method for adaptive step sizing. Uses 2 stages. Uses 2nd order Hermite interpolation for dense output.

When used to solve SDEs, converges to the Stratonovich solution.

####  diffrax.Bosh3 (AbstractERK) ¤

Bogacki--Shampine's 3/2 method.

3rd order explicit Runge--Kutta method. Has an embedded 2nd order method for adaptive step sizing. Uses 4 stages with FSAL. Uses 3rd order Hermite interpolation for dense/ts output.

Also sometimes known as "Ralston's third order method".

####  diffrax.Tsit5 (AbstractERK) ¤

Tsitouras' 5/4 method.

5th order explicit Runge--Kutta method. Has an embedded 4th order method for adaptive step sizing. Uses 7 stages with FSAL. Uses 5th order interpolation for dense/ts output.

Reference
@article{tsitouras2011runge,
title={Runge--Kutta pairs of order 5 (4) satisfying only the first column
simplifying assumption},
author={Tsitouras, Ch},
journal={Computers \& Mathematics with Applications},
volume={62},
number={2},
pages={770--775},
year={2011},
publisher={Elsevier}
}


####  diffrax.Dopri5 (AbstractERK) ¤

Dormand-Prince's 5/4 method.

5th order Runge--Kutta method. Has an embedded 4th order method for adaptive step sizing. Uses 7 stages with FSAL. Uses 5th order interpolation for dense/ts output.

Reference

The original reference for Dormand--Prince's 5(4) method is:

@article{dormand1980family,
author={Dormand, J. R. and Prince, P. J.},
title={A family of embedded {R}unge--{K}utta formulae},
journal={J. Comp. Appl. Math},
year={1980},
volume={6},
pages={19--26}
}


However (despite the name), the Butcher tableau used here is actually due to Shampine:

@article{shampine1986some,
author={Lawrence F. Shampine},
journal={Mathematics of Computation},
number={173},
pages={135--150},
publisher={American Mathematical Society},
title={Some Practical {R}unge-{K}utta Formulas},
volume={46},
year={1986},
doi={https://doi.org/10.2307/2008219}
}


####  diffrax.Dopri8 (AbstractERK) ¤

Dormand--Prince's 8/7 method.

8th order Runge--Kutta method. Has an embedded 7th order method for adaptive step sizing. Uses 14 stages with FSAL. Uses 8th order interpolation for dense/ts output.

References

Coefficients from:

@article{prince1981high,
author={Prince, P. J and Dormand, J. R.},
title={High order embedded {R}unge--{K}utta formulae},
journal={J. Comp. Appl. Math},
year={1981},
volume={7},
number={1},
pages={67--75}
}


Dense interpolation from:

@article{bogacki1990interpolating,
author={Bogacki, P. and Shampine, L. F.},
title={Interpolating high-order {R}unge--{K}utta formulas},
journal={Comput. Math. with Appl.},
year={1990},
volume={20},
number={3},
pages={15--24},
doi={https://doi.org/10.1016/0898-1221(90)90027-H}
}


### Implicit Runge--Kutta (IRK) methods¤

These methods are suitable for stiff problems.

Each of these takes a root_finder argument at initialisation, defaulting to a Newton solver, which is used to solve the implicit problem at each step. See the page on root finders.

####  diffrax.ImplicitEuler (AbstractImplicitSolver, AbstractAdaptiveSolver) ¤

Implicit Euler method.

A-B-L stable 1st order SDIRK method. Has an embedded 2nd order Heun method for adaptive step sizing. Uses 1 stage. Uses a 1st order local linear interpolation for dense/ts output.

####  diffrax.Kvaerno3 (AbstractESDIRK) ¤

Kvaerno's 3/2 method.

A-L stable stiffly accurate 3rd order ESDIRK method. Has an embedded 2nd order method for adaptive step sizing. Uses 4 stages with FSAL. Uses 3rd order Hermite interpolation for dense/ts output.

Reference
@article{kvaerno2004singly,
title={Singly diagonally implicit Runge--Kutta methods with an explicit first
stage},
author={Kv{\ae}rn{\o}, Anne},
journal={BIT Numerical Mathematics},
volume={44},
number={3},
pages={489--502},
year={2004},
publisher={Springer}
}


####  diffrax.Kvaerno4 (AbstractESDIRK) ¤

Kvaerno's 4/3 method.

A-L stable stiffly accurate 4th order ESDIRK method. Has an embedded 3rd order method for adaptive step sizing. Uses 5 stages with FSAL. Uses 3rd order Hermite interpolation for dense/ts output.

When solving an ODE over the interval $$[t_0, t_1]$$, note that this method will make some evaluations slightly past $$t_1$$.

Reference
@article{kvaerno2004singly,
title={Singly diagonally implicit Runge--Kutta methods with an explicit first
stage},
author={Kv{\ae}rn{\o}, Anne},
journal={BIT Numerical Mathematics},
volume={44},
number={3},
pages={489--502},
year={2004},
publisher={Springer}
}


####  diffrax.Kvaerno5 (AbstractESDIRK) ¤

Kvaerno's 5/4 method.

A-L stable stiffly accurate 5th order ESDIRK method. Has an embedded 4th order method for adaptive step sizing. Uses 7 stages with FSAL. Uses 3rd order Hermite interpolation for dense/ts output.

When solving an ODE over the interval $$[t_0, t_1]$$, note that this method will make some evaluations slightly past $$t_1$$.

Reference
@article{kvaerno2004singly,
title={Singly diagonally implicit Runge--Kutta methods with an explicit first
stage},
author={Kv{\ae}rn{\o}, Anne},
journal={BIT Numerical Mathematics},
volume={44},
number={3},
pages={489--502},
year={2004},
publisher={Springer}
}


### IMEX methods¤

These "implicit-explicit" methods are suitable for problems of the form $$\frac{\mathrm{d}y}{\mathrm{d}t} = f(t, y(t)) + g(t, y(t))$$, where $$f$$ is the non-stiff part (explicit integration) and $$g$$ is the stiff part (implicit integration).

Term structure

These methods should be called with terms=MultiTerm(explicit_term, implicit_term).

####  diffrax.Sil3 (AbstractRungeKutta, AbstractImplicitSolver) ¤

Whitaker--Kar's fast-slow IMEX method.

3rd order in the explicit (ERK) term; 2nd order in the implicit (EDIRK) term. Uses a 2nd-order embedded Heun method for adaptive step sizing. Uses 4 stages with FSAL. Uses 2nd order Hermite interpolation for dense/ts output.

This should be called with terms=MultiTerm(explicit_term, implicit_term).

Reference
@article{whitaker2013implicit,
author={Jeffrey S. Whitaker and Sajal K. Kar},
title={Implicit–Explicit Runge–Kutta Methods for Fast–Slow Wave Problems},
journal={Monthly Weather Review},
year={2013},
publisher={American Meteorological Society},
volume={141},
number={10},
doi={https://doi.org/10.1175/MWR-D-13-00132.1},
pages={3426--3434},
}


####  diffrax.KenCarp3 (AbstractRungeKutta, AbstractImplicitSolver) ¤

Kennedy--Carpenter's 3/2 IMEX method.

3rd order ERK-ESDIRK implicit-explicit (IMEX) method. The implicit part is stiffly accurate and A-L stable. Has an embedded 2nd order method for adaptive step sizing. Uses 4 stages. Uses 2nd order interpolation for dense/ts output.

This should be called with terms=MultiTerm(explicit_term, implicit_term).

Reference
@article{kennedy2003additive,
equations},
author={Kennedy, Christopher A and Carpenter, Mark H},
journal={Applied numerical mathematics},
volume={44},
number={1-2},
pages={139--181},
year={2003},
publisher={Elsevier}
}


####  diffrax.KenCarp4 (AbstractRungeKutta, AbstractImplicitSolver) ¤

Kennedy--Carpenter's 4/3 IMEX method.

4th order ERK-ESDIRK implicit-explicit (IMEX) method. The implicit part is stiffly accurate and A-L stable. Has an embedded 3rd order method for adaptive step sizing. Uses 6 stages. Uses 3rd order interpolation for dense/ts output.

This should be called with terms=MultiTerm(explicit_term, implicit_term).

Reference
@article{kennedy2003additive,
equations},
author={Kennedy, Christopher A and Carpenter, Mark H},
journal={Applied numerical mathematics},
volume={44},
number={1-2},
pages={139--181},
year={2003},
publisher={Elsevier}
}


####  diffrax.KenCarp5 (AbstractRungeKutta, AbstractImplicitSolver) ¤

Kennedy--Carpenter's 5/4 IMEX method.

5th order ERK-ESDIRK implicit-explicit (IMEX) method. The implicit part is stiffly accurate and A-L stable. Has an embedded 4th order method for adaptive step sizing. Uses 8 stages. Uses 3rd order interpolation for dense/ts output.

This should be called with terms=MultiTerm(explicit_term, implicit_term).

Reference
@article{kennedy2003additive,
equations},
author={Kennedy, Christopher A and Carpenter, Mark H},
journal={Applied numerical mathematics},
volume={44},
number={1-2},
pages={139--181},
year={2003},
publisher={Elsevier}
}


### Symplectic methods¤

These methods are suitable for problems with symplectic structure; that is to say those ODEs of the form

$$\frac{\mathrm{d}v}{\mathrm{d}t}(t) = f(t, w(t))$$

$$\frac{\mathrm{d}w}{\mathrm{d}t}(t) = g(t, v(t))$$

In particular this includes Hamiltonian systems.

Term and state structure

The state of the system (the initial value of which is given by y0 to diffrax.diffeqsolve) must be a 2-tuple (of PyTrees). The terms (given by the value of terms to diffrax.diffeqsolve) must be a 2-tuple of AbstractTerms.

Letting v, w = y0 and f, g = terms, then v is updated according to f(t, w, args) and w is updated according to g(t, v, args).

####  diffrax.SemiImplicitEuler (AbstractSolver) ¤

Semi-implicit Euler's method.

Symplectic method. Does not support adaptive step sizing. Uses 1st order local linear interpolation for dense/ts output.

### Reversible methods¤

These methods can be run "in reverse": solving from an initial condition y0 to obtain some terminal value y1, it is possible to reconstruct y0 from y1 with zero truncation error. (There will still be a small amount of floating point error.) This can be done via SaveAt(solver_state=True) to save the final solver state, and then passing it as diffeqsolve(..., solver_state=solver_state) on the backwards-in-time pass.

In addition all symplectic methods are reversible, as are some linear multistep methods. (Below are the non-symplectic reversible solvers.)

####  diffrax.ReversibleHeun (AbstractAdaptiveSolver, AbstractStratonovichSolver) ¤

Reversible Heun method.

Algebraically reversible 2nd order method. Has an embedded 1st order method for adaptive step sizing. Uses 1st order local linear interpolation for dense/ts output.

When used to solve SDEs, converges to the Stratonovich solution.

Reference
@article{kidger2021efficient,
author={Kidger, Patrick and Foster, James and Li, Xuechen and Lyons, Terry},
title={{E}fficient and {A}ccurate {G}radients for {N}eural {SDE}s},
year={2021},
journal={Advances in Neural Information Processing Systems}
}


### Linear multistep methods¤

####  diffrax.LeapfrogMidpoint (AbstractSolver) ¤

Leapfrog/midpoint method.

2nd order linear multistep method. Uses 1st order local linear interpolation for dense/ts output.

Note that this is referred to as the "leapfrog/midpoint method" as this is the name used by Shampine in the reference below. It should not be confused with any of the many other "leapfrog methods" (there are several), or with the "midpoint method" (which is usually taken to refer to the explicit Runge--Kutta method diffrax.Midpoint).

Reference
@article{shampine2009stability,
title={Stability of the leapfrog/midpoint method},
author={L. F. Shampine},
journal={Applied Mathematics and Computation},
volume={208},
number={1},
pages={293-298},
year={2009},
}