Differential equations (DE) are mathematical equations that describe how a
quantity changes as a function of one or several (independent) variables, often
time or space.
Differential equations play an important role in biology, chemistry, physics,
engineering, economy and other disciplines.
Differential equations can be separated into stochastic versus deterministic
DEs. Problems can be split into initial value problems versus boundary value problems.
One also distinguishes ordinary differential equations from
partial differential equations, differential algebraic equations and delay differential equations.
All these types of DEs can be solved in R.
DE problems can be classified to be either stiff or nonstiff; the former type of problems are
much more difficult to solve.
The
dynamic models SIG
is a suitable mailing list for discussing the use of R for solving differential equation
and other dynamic models such as individualbased or agentbased models.
This task view was created to provide an overview on the topic.
If we forgot something, or if a new package should be mentioned here, please let
us
know.
Stochastic Differential Equations (SDEs)
In a stochastic differential equation, the unknown quantity is a
stochastic process.

The package
sde
provides functions for simulation and inference for
stochastic differential equations. It is the accompanying package to
the book by Iacus (2008).

The package
pomp
contains functions for statistical inference for
partially observed Markov processes.

Packages
adaptivetau
and
GillespieSSA
implement
Gillespie's "exact" stochastic simulation algorithm (direct method)
and several approximate methods.

The package
Sim.DiffProc
provides functions for simulation of
ItÃ´ and Stratonovitch stochastic differential equations.

Package
QPot
analyzes 2dimensional systems of stochastic
differential equations using quasipotential analysis.

Package
diffeqr
can solve SDE problems using the
DifferentialEquations.jl
package from the Julia programming language.
Ordinary Differential Equations (ODEs)
In an ODE, the unknown quantity is a function of a single independent variable.
Several packages offer to solve ODEs.

The "odesolve" package was the first to solve ordinary differential equations in R.
It contained two integration methods. It has been replaced by the package
deSolve.

The package
deSolve
contains several solvers for solving ODE, DAE, DDE and PDE.
It can deal with stiff and nonstiff problems.

The package
deTestSet
contains solvers designed for solving
very stiff equations.

The package
odeintr
generates and compiles C++ ODE solvers on the fly using Rcpp
and
Boost
odeint
.

The R package
diffeqr
provides a seamless interface to the
DifferentialEquations.jl
package from the Julia programming language. It has unique high performance methods for solving ODE, SDE, DDE, DAE and more.
Models can be written in either R or Julia. It requires an installation of the Julia language.

Package
pracma
implements several adaptive RungeKutta
solvers such as ode23, ode23s, ode45, or the BurlischStoer algorithm to obtain
numerical solutions to ODEs with higher accuracy.

Package
rODE
(inspired from the book of Gould, Tobochnik and Christian, 2016)
aims to show physics, math and engineering students
how ODE solvers can be made with R's S4 classes.

Package
sundialr
provides a way to call the 'CVODE' function from the 'SUNDIALS' C ODE solving library.
The package requires the ODE to be written as an 'R' or 'Rcpp' function.
Delay Differential Equations (DDEs)
In a DDE, the derivative at a certain time is a function of the variable value at a previous time.

The
dde
package implements solvers for ordinary (ODE) and delay (DDE) differential equations,
where the objective function is written in either R or C. Suitable only for nonstiff equations.
Support is also included for iterating difference equations.

The package
PBSddesolve
(originally published as "ddesolve")
includes a solver for nonstiff DDE problems.

Functions in the package
deSolve
can solve both stiff and nonstiff DDE problems.

Package
diffeqr
can solve DDE problems using the
DifferentialEquations.jl
package from the Julia programming language.
Partial Differential Equations (PDEs)
PDEs are differential equations in which the unknown quantity is a
function of multiple independent variables. A common classification is
into elliptic (timeindependent), hyperbolic (timedependent and wavelike),
and parabolic (timedependent and diffusive) equations.
One way to solve them is to rewrite the PDEs as a set of coupled
ODEs, and then use an efficient solver.

The Rpackage
ReacTran
provides functions for converting the PDEs
into a set of ODEs. Its main target is in the field of ''reactive transport''
modelling, but it can be used to solve PDEs of the three main types.
It provides functions for discretising PDEs on cartesian, polar,
cylindrical and spherical grids.

The package
deSolve
contains dedicated solvers for 1D, 2D and
3D timevarying ODE problems as generated from PDEs (e.g. by
ReacTran).

Solvers for 1D time varying problems can also be found in the package
deTestSet.

The package
rootSolve
contains optimized solvers for 1D, 2D and
3D algebraic problems generated from (timeinvariant) PDEs.
It can thus be used for solving elliptic equations.
Note that, to date, PDEs in R can only be solved using finite differences.
At some point, we hope that finite element and spectral methods will become available.
Differential Algebraic Equations (DAEs)
Differential algebraic equations comprise both differential and algebraic terms.
An important feature of a DAE is its differentiation index; the higher this index,
the more difficult to solve the DAE.

The package
deSolve
provides two solvers, that can handle DAEs up to index 3.

Three more DAE solvers are in the package
deTestSet.

Package
diffeqr
can solve DAE problems using the
DifferentialEquations.jl
package from the Julia programming language.
Boundary Value Problems (BVPs)
BVPs have solutions and/or derivative conditions specified
at the boundaries of the independent variable.

Package
bvpSolve
deals only with this type of equations.

The package
ReacTran
can solve BVPs that belong to the
class of reactive transport equations.

Package
diffeqr
can also solve BVPs using the
DifferentialEquations.jl
package from the Julia programming language.
Other

The
simecol
package provides an interactive environment to
implement and simulate dynamic models.
Next to DE models, it also provides functions for gridoriented,
individualbased, and particle diffusion models.

The
RxODE
package provides facilities for running simulations from ordinary
differential equation (ODE) models. A compilation manager translates the ODE model into C,
compiles it, and dynamically loads the object code into R for improved computational efficiency.
Additionally, RxODE allows ODEs to be solved in parallel using the liblsoda library and OpenMP.

Package
scaRabee
offers frameworks for simulation and optimization of PharmacokineticPharmacodynamic Models.

In the package
FME
are functions for inverse modelling (fitting to data),
sensitivity analysis, identifiability and Monte Carlo Analysis of DE models.

The package
nlmeODE
has functions for
mixedeffects modelling using differential equations.

mkin
provides routines for fitting kinetic models with one
or more state variables to chemical degradation data.

Package
dMod
provides functions to generate ODEs of reaction networks,
parameter transformations, observation functions, residual functions, etc.
It follows the paradigm that derivative information should be used for optimization whenever possible.

The package
CollocInfer
implements collocationinference
for continuoustime and discretetime stochastic processes.

Root finding, equilibrium and steadystate analysis of ODEs can be
done with the package
rootSolve.

The
deTestSet
package contains many test problems for differential equations.

The
PBSmodelling
package adds GUI functions to models.

phaseR
is an R package for the qualitative analysis of one and
two dimensional autonomous ODE systems, using phase plane methods.

Package
cOde
supports the automatic creation of dynamically linked
code for packages
deSolve
bvpSolve
(or a builtin implementation
of the sundials cvode solver) from inline C embedded in the R code.

Package
rodeo
is an object oriented system and code generator that
creates and compiles efficient Fortran code for
deSolve
from models
defined in stoichiomatry matrix notation.

Package
ecolMod
contains the figures, data sets and examples from a book
on ecological modelling (Soetaert and Herman, 2009).

primer
is a support package for the book of Stevens (2009).