The ode package provides classes to solve Ordinary Differential Equations problems.
This package solves Initial Value Problems of the form y'=f(t,y) with t0 and y(t0)=y0 known. The provided integrators compute an estimate of y(t) from t=t0 to t=t1.
All integrators provide dense output. This means that besides computing the state vector at discrete times, they also provide a cheap mean to get the state between the time steps. They do so through classes extending the StepInterpolator abstract class, which are made available to the user at the end of each step.
All integrators handle multiple switching functions. This means that the integrator can be
driven by discrete events (occurring when the signs of user-supplied
switching functions
change). The steps are shortened as needed to ensure the events occur at step boundaries (even
if the integrator is a fixed-step integrator). When the events are triggered, integration can
be stopped (this is called a G-stop facility), the state vector can be changed, or integration
can simply go on. The latter case is useful to handle discontinuities in the differential
equations gracefully and get accurate dense output even close to the discontinuity. The events
are detected when the functions signs are different at the beginning and end of the current step,
or at several equidistant points inside the step if its length becomes larger than the maximal
checking interval specified for the given switching function. This time interval should be set
appropriately to avoid missing some switching function sign changes (it is possible to set it
to Double.POSITIVE_INFINITY
if the sign changes cannot be missed).
The user should describe his problem in his own classes which should implement the FirstOrderDifferentialEquations interface. Then he should pass it to the integrator he prefers among all the classes that implement the FirstOrderIntegrator interface.
The solution of the integration problem is provided by two means. The first one is aimed towards
simple use: the state vector at the end of the integration process is copied in the y array of the
FirstOrderIntegrator.integrate
method. The second one should be used when more in-depth
information is needed throughout the integration process. The user can register an object implementing
the StepHandler
interface or a
StepNormalizer
object wrapping
a user-specified object implementing the
FixedStepHandler
interface
into the integrator before calling the FirstOrderIntegrator.integrate
method. The user object
will be called appropriately during the integration process, allowing the user to process intermediate
results. The default step handler does nothing.
ContinuousOutputModel
is a special-purpose step handler that is able to store all steps and to provide transparent access to
any intermediate result once the integration is over. An important feature of this class is that it
implements the Serializable
interface. This means that a complete continuous model of the
integrated function throughout the integration range can be serialized and reused later (if stored into
a persistent medium like a file system or a database) or elsewhere (if sent to another application).
Only the result of the integration is stored, there is no reference to the integrated problem by itself.
Other default implementations of the StepHandler interface are available for general needs (DummyStepHandler , StepNormalizer ) and custom implementations can be developped for specific needs. As an example, if an application is to be completely driven by the integration process, then most of the application code will be run inside a step handler specific to this application.
Some integrators (the simple ones) use fixed steps that are set at creation time. The more efficient integrators use variable steps that are handled internally in order to control the integration error with respect to a specified accuracy (these integrators extend the AdaptiveStepsizeIntegrator abstract class). In this case, the step handler which is called after each successful step shows up the variable stepsize. The StepNormalizer class can be used to convert the variable stepsize into a fixed stepsize that can be handled by classes implementing the FixedStepHandler interface. Adaptive stepsize integrators can automatically compute the initial stepsize by themselves, however the user can specify it if he prefers to retain full control over the integration or if the automatic guess is wrong.
First order ODE problems are defined by implementing the
FirstOrderDifferentialEquations
interface before they can be handled by the integrators FirstOrderIntegrator.integrate
method.
A first order differential equations problem, as seen by an integrator is the time
derivative dY/dt
of a state vector Y
, both being one
dimensional arrays. From the integrator point of view, this derivative depends
only on the current time t
and on the state vector Y
.
For real world problems, the derivative depends also on parameters that do not belong to the state vector (dynamical model constants for example). These constants are completely outside of the scope of this interface, the classes that implement it are allowed to handle them as they want.
The tables below show the various integrators available.
Fixed Step Integrators | |
Name | Order |
Euler | 1 |
Midpoint | 2 |
Classical Runge-Kutta | 4 |
Gill | 4 |
3/8 | 4 |
Adaptive Stepsize Integrators | ||
Name | Integration Order | Error Estimation Order |
Higham and Hall | 5 | 4 |
Dormand-Prince 5(4) | 5 | 4 |
Dormand-Prince 8(5,3) | 8 | 5 and 3 |
Gragg-Bulirsch-Stoer variable (up to 18 by default) | variable |