See: Description
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  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  Description 

LocalizedODEFormats 
Enumeration for localized messages formats used in exceptions messages.

Exception  Description 

VariationalEquation.MismatchedEquations 
Special exception for equations mismatch.

This package provides classes to solve Ordinary Differential Equations problems.
This package solves Initial Value Problems of the form
y'=f(t,y)
with t_{0}
and
y(t_{0})=y_{0}
known. The provided
integrators compute an estimate of y(t)
from
t=t_{0}
to t=t_{1}
.
It is also possible to get thederivatives with respect to the initial state
dy(t)/dy(t_{0})
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 fixedstep
integrator). When the events are triggered, integration can be stopped
(this is called a Gstop 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 indepth information is needed throughout the integration
process. The user can register an object implementing the ODEStepHandler
interface or a
StepNormalizer
object wrapping a userspecified 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 specialpurpose 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 RungeKutta  4 
Gill  4 
3/8  4 
Luther  6 
Adaptive Stepsize Integrators  
Name  Integration Order  Error Estimation Order 
Higham and Hall  5  4 
DormandPrince 5(4)  5  4 
DormandPrince 8(5,3)  8  5 and 3 
GraggBulirschStoer  variable (up to 18 by default)  variable 
AdamsBashforth  variable  variable 
AdamsMoulton  variable  variable 
In the table above, the AdamsBashforth
and AdamsMoulton
integrators appear as variablestep ones. This is an extension
to the classical algorithms using the Nordsieck vector representation.
Copyright © 20162022 CS GROUP. All rights reserved.