Package org.hipparchus.ode

This package provides classes to solve Ordinary Differential Equations problems.

See: Description

Interface Summary

Interface	Description
ComplexOrdinaryDifferentialEquation	This interface represents a first order differential equations set for complex state.
ComplexSecondaryODE	This interface allows users to add secondary differential equations to a primary set of differential equations.
FieldODEIntegrator<T extends CalculusFieldElement<T>>	This interface represents a first order integrator for differential equations.
FieldOrdinaryDifferentialEquation<T extends CalculusFieldElement<T>>	This interface represents a first order differential equations set.
FieldSecondaryODE<T extends CalculusFieldElement<T>>	This interface allows users to add secondary differential equations to a primary set of differential equations.
NamedParameterJacobianProvider	Interface to compute exactly Jacobian matrix for some parameter when computing partial derivatives equations.
ODEIntegrator	This interface represents a first order integrator for differential equations.
ODEJacobiansProvider	Interface expanding first order differential equations in order to compute exactly the Jacobian matrices for partial derivatives equations.
OrdinaryDifferentialEquation	This interface represents a first order differential equations set.
Parameterizable	This interface enables to process any parameterizable object.
ParametersController	Interface to compute by finite difference Jacobian matrix for some parameter when computing partial derivatives equations.
SecondaryODE	This interface allows users to add secondary differential equations to a primary set of differential equations.
SecondOrderODE	This interface represents a second order differential equations set.

Class Summary

Class	Description
AbstractFieldIntegrator<T extends CalculusFieldElement<T>>	Base class managing common boilerplate for all integrators.
AbstractIntegrator	Base class managing common boilerplate for all integrators.
AbstractParameterizable	This abstract class provides boilerplate parameters list.
ComplexODEConverter	This class converts complex Ordinary Differential Equations into real ones.
ComplexODEState	Container for time, main and secondary state vectors.
ComplexODEStateAndDerivative	Container for time, main and secondary state vectors as well as their derivatives.
DenseOutputModel	This class stores all information provided by an ODE integrator during the integration process and build a continuous model of the solution from this.
EquationsMapper	Class mapping the part of a complete state or derivative that pertains to a specific differential equation.
ExpandableODE	This class represents a combined set of first order differential equations, with at least a primary set of equations expandable by some sets of secondary equations.
FieldDenseOutputModel<T extends CalculusFieldElement<T>>	This class stores all information provided by an ODE integrator during the integration process and build a continuous model of the solution from this.
FieldEquationsMapper<T extends CalculusFieldElement<T>>	Class mapping the part of a complete state or derivative that pertains to a set of differential equations.
FieldExpandableODE<T extends CalculusFieldElement<T>>	This class represents a combined set of first order differential equations, with at least a primary set of equations expandable by some sets of secondary equations.
FieldODEState<T extends CalculusFieldElement<T>>	Container for time, main and secondary state vectors.
FieldODEStateAndDerivative<T extends CalculusFieldElement<T>>	Container for time, main and secondary state vectors as well as their derivatives.
FirstOrderConverter	This class converts second order differential equations to first order ones.
MultistepFieldIntegrator<T extends CalculusFieldElement<T>>	This class is the base class for multistep integrators for Ordinary Differential Equations.
MultistepIntegrator	This class is the base class for multistep integrators for Ordinary Differential Equations.
ODEState	Container for time, main and secondary state vectors.
ODEStateAndDerivative	Container for time, main and secondary state vectors as well as their derivatives.
ParameterConfiguration	Simple container pairing a parameter name with a step in order to compute the associated Jacobian matrix by finite difference.
VariationalEquation	This class defines a set of secondary equations to compute the global Jacobian matrices with respect to the initial state vector and, if any, to some parameters of the primary ODE set.

Enum Summary

Enum	Description
LocalizedODEFormats	Enumeration for localized messages formats used in exceptions messages.

Exception Summary

Exception	Description
VariationalEquation.MismatchedEquations	Special exception for equations mismatch.

Package org.hipparchus.ode Description

This 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. It is also possible to get thederivatives with respect to the initial state dy(t)/dy(t0) or the derivatives with respect to some ODE parameters dy(t)/dp.

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 ODEStateInterpolator abstract class, which are made available to the user at the end of each step.

All integrators handle multiple discrete events detection based on switching functions. This means that the integrator can be driven by user specified discrete events. 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. See org.hipparchus.ode.events for more on how events are handled.

The user should describe his problem in his own classes (UserProblem in the diagram below) which should implement the OrdinaryDifferentialEquation interface. Then he should pass it to the integrator he prefers among all the classes that implement the ODEIntegrator 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 ODEIntegrator.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 ODEStepHandler interface or a StepNormalizer object wrapping a user-specified object implementing the ODEFixedStepHandler interface into the integrator before calling the ODEIntegrator.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.

DenseOutputModel 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 filesystem 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.

Custom implementations can be developed 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 ODEFixedStepHandler 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.

Fixed Step Integrators
Name	Order
Euler	1
Midpoint	2
Classical Runge-Kutta	4
Gill	4
3/8	4
Luther	6

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
Adams-Bashforth	variable	variable
Adams-Moulton	variable	variable

In the table above, the Adams-Bashforth and Adams-Moulton integrators appear as variable-step ones. This is an extension to the classical algorithms using the Nordsieck vector representation.