Top Description Fields Constructors Methods
org.apache.commons.math3.ode.nonstiff

public Class AdamsBashforthFieldIntegrator<T extends RealFieldElement<T>>

extends AdamsFieldIntegrator<T extends RealFieldElement<T>>
Class Inheritance
Type Parameters
<T>
the type of the field elements
Imports
org.apache.commons.math3.Field, .RealFieldElement, org.apache.commons.math3.exception.DimensionMismatchException, .MaxCountExceededException, .NoBracketingException, .NumberIsTooSmallException, org.apache.commons.math3.linear.Array2DRowFieldMatrix, .FieldMatrix, org.apache.commons.math3.ode.FieldExpandableODE, .FieldODEState, .FieldODEStateAndDerivative, org.apache.commons.math3.util.MathArrays

This class implements explicit Adams-Bashforth integrators for Ordinary Differential Equations.

Adams-Bashforth methods (in fact due to Adams alone) are explicit multistep ODE solvers. This implementation is a variation of the classical one: it uses adaptive stepsize to implement error control, whereas classical implementations are fixed step size. The value of state vector at step n+1 is a simple combination of the value at step n and of the derivatives at steps n, n-1, n-2 ... Depending on the number k of previous steps one wants to use for computing the next value, different formulas are available:

A k-steps Adams-Bashforth method is of order k.

Implementation details

We define scaled derivatives si(n) at step n as:

s1(n) = h y'n for first derivative
s2(n) = h2/2 y''n for second derivative
s3(n) = h3/6 y'''n for third derivative
...
sk(n) = hk/k! y(k)n for kth derivative

The definitions above use the classical representation with several previous first derivatives. Lets define

  qn = [ s1(n-1) s1(n-2) ... s1(n-(k-1)) ]T
(we omit the k index in the notation for clarity). With these definitions, Adams-Bashforth methods can be written:

Instead of using the classical representation with first derivatives only (yn, s1(n) and qn), our implementation uses the Nordsieck vector with higher degrees scaled derivatives all taken at the same step (yn, s1(n) and rn) where rn is defined as:

rn = [ s2(n), s3(n) ... sk(n) ]T
(here again we omit the k index in the notation for clarity)

Taylor series formulas show that for any index offset i, s1(n-i) can be computed from s1(n), s2(n) ... sk(n), the formula being exact for degree k polynomials.

s1(n-i) = s1(n) + ∑j>0 (j+1) (-i)j sj+1(n)
The previous formula can be used with several values for i to compute the transform between classical representation and Nordsieck vector. The transform between rn and qn resulting from the Taylor series formulas above is:
qn = s1(n) u + P rn
where u is the [ 1 1 ... 1 ]T vector and P is the (k-1)×(k-1) matrix built with the (j+1) (-i)j terms with i being the row number starting from 1 and j being the column number starting from 1:
       [  -2   3   -4    5  ... ]
       [  -4  12  -32   80  ... ]
  P =  [  -6  27 -108  405  ... ]
       [  -8  48 -256 1280  ... ]
       [          ...           ]

Using the Nordsieck vector has several advantages:

The Nordsieck vector at step n+1 is computed from the Nordsieck vector at step n as follows:

where A is a rows shifting matrix (the lower left part is an identity matrix):
       [ 0 0   ...  0 0 | 0 ]
       [ ---------------+---]
       [ 1 0   ...  0 0 | 0 ]
   A = [ 0 1   ...  0 0 | 0 ]
       [       ...      | 0 ]
       [ 0 0   ...  1 0 | 0 ]
       [ 0 0   ...  0 1 | 0 ]

The P-1u vector and the P-1 A P matrix do not depend on the state, they only depend on k and therefore are precomputed once for all.

Since
3.6

Field Summary

Modifier and TypeField and Description
private static final String
METHOD_NAME

Integrator method name.

Constructor Summary

AccessConstructor and Description
public
AdamsBashforthFieldIntegrator(final Field<T>
field to which the time and state vector elements belong
field
,
final int
number of steps of the method excluding the one being computed
nSteps
,
final double
minimal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
minStep
,
final double
maximal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
maxStep
,
final double
allowed absolute error
scalAbsoluteTolerance
,
final double
allowed relative error
scalRelativeTolerance
)

Build an Adams-Bashforth integrator with the given order and step control parameters.

public
AdamsBashforthFieldIntegrator(final Field<T>
field to which the time and state vector elements belong
field
,
final int
number of steps of the method excluding the one being computed
nSteps
,
final double
minimal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
minStep
,
final double
maximal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
maxStep
,
final double[]
allowed absolute error
vecAbsoluteTolerance
,
final double[]
allowed relative error
vecRelativeTolerance
)

Build an Adams-Bashforth integrator with the given order and step control parameters.

Method Summary

Modifier and TypeMethod and Description
private T

Returns:

estimated normalized local discretization error
errorEstimation
(final T[]
state vector at step start
previousState
,
final T[]
predicted state vector at step end
predictedState
,
final T[]
predicted value of the scaled derivatives at step end
predictedScaled
,
final FieldMatrix<T>
predicted value of the Nordsieck vector at step end
predictedNordsieck
)

Estimate error.

public FieldODEStateAndDerivative<T>
integrate(final FieldExpandableODE<T>
differential equations to integrate
equations
,
final FieldODEState<T>
initial state (time, primary and secondary state vectors)
initialState
,
final T
target time for the integration (can be set to a value smaller than t0 for backward integration)
finalTime
)

Implements abstract org.apache.commons.math3.ode.nonstiff.AdamsFieldIntegrator.integrate.

Implements org.apache.commons.math3.ode.FirstOrderFieldIntegrator.integrate.

Integrate the differential equations up to the given time.

Inherited from org.apache.commons.math3.ode.nonstiff.AdamsFieldIntegrator:
initializeHighOrderDerivativesupdateHighOrderDerivativesPhase1updateHighOrderDerivativesPhase2

Field Detail

METHOD_NAMEback to summary
private static final String METHOD_NAME

Integrator method name.

Constructor Detail

AdamsBashforthFieldIntegratorback to summary
public AdamsBashforthFieldIntegrator(final Field<T> field, final int nSteps, final double minStep, final double maxStep, final double scalAbsoluteTolerance, final double scalRelativeTolerance) throws NumberIsTooSmallException

Build an Adams-Bashforth integrator with the given order and step control parameters.

Parameters
field:Field<T>

field to which the time and state vector elements belong

nSteps:int

number of steps of the method excluding the one being computed

minStep:double

minimal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this

maxStep:double

maximal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this

scalAbsoluteTolerance:double

allowed absolute error

scalRelativeTolerance:double

allowed relative error

Exceptions
NumberIsTooSmallException:
if order is 1 or less
AdamsBashforthFieldIntegratorback to summary
public AdamsBashforthFieldIntegrator(final Field<T> field, final int nSteps, final double minStep, final double maxStep, final double[] vecAbsoluteTolerance, final double[] vecRelativeTolerance) throws IllegalArgumentException

Build an Adams-Bashforth integrator with the given order and step control parameters.

Parameters
field:Field<T>

field to which the time and state vector elements belong

nSteps:int

number of steps of the method excluding the one being computed

minStep:double

minimal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this

maxStep:double

maximal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this

vecAbsoluteTolerance:double[]

allowed absolute error

vecRelativeTolerance:double[]

allowed relative error

Exceptions
IllegalArgumentException:
if order is 1 or less

Method Detail

errorEstimationback to summary
private T errorEstimation(final T[] previousState, final T[] predictedState, final T[] predictedScaled, final FieldMatrix<T> predictedNordsieck)

Estimate error.

Error is estimated by interpolating back to previous state using the state Taylor expansion and comparing to real previous state.

Parameters
previousState:T[]

state vector at step start

predictedState:T[]

predicted state vector at step end

predictedScaled:T[]

predicted value of the scaled derivatives at step end

predictedNordsieck:FieldMatrix<T>

predicted value of the Nordsieck vector at step end

Returns:T

estimated normalized local discretization error

integrateback to summary
public FieldODEStateAndDerivative<T> integrate(final FieldExpandableODE<T> equations, final FieldODEState<T> initialState, final T finalTime) throws NumberIsTooSmallException, DimensionMismatchException, MaxCountExceededException, NoBracketingException

Implements abstract org.apache.commons.math3.ode.nonstiff.AdamsFieldIntegrator.integrate.

Implements org.apache.commons.math3.ode.FirstOrderFieldIntegrator.integrate.

Doc from org.apache.commons.math3.ode.nonstiff.AdamsFieldIntegrator.integrate.

Integrate the differential equations up to the given time.

This method solves an Initial Value Problem (IVP).

Since this method stores some internal state variables made available in its public interface during integration (getCurrentSignedStepsize()), it is not thread-safe.

Parameters
equations:FieldExpandableODE<T>

Doc from org.apache.commons.math3.ode.FirstOrderFieldIntegrator.integrate.

differential equations to integrate

initialState:FieldODEState<T>

Doc from org.apache.commons.math3.ode.FirstOrderFieldIntegrator.integrate.

initial state (time, primary and secondary state vectors)

finalTime:T

Doc from org.apache.commons.math3.ode.FirstOrderFieldIntegrator.integrate.

target time for the integration (can be set to a value smaller than t0 for backward integration)

Returns:FieldODEStateAndDerivative<T>

Doc from org.apache.commons.math3.ode.FirstOrderFieldIntegrator.integrate.

final state, its time will be the same as finalTime if integration reached its target, but may be different if some org.apache.commons.math3.ode.events.FieldEventHandler stops it at some point.

Annotations
@Override
Exceptions
NumberIsTooSmallException:

Doc from org.apache.commons.math3.ode.FirstOrderFieldIntegrator.integrate.

if integration step is too small

MaxCountExceededException:

Doc from org.apache.commons.math3.ode.FirstOrderFieldIntegrator.integrate.

if the number of functions evaluations is exceeded

NoBracketingException:

Doc from org.apache.commons.math3.ode.FirstOrderFieldIntegrator.integrate.

if the location of an event cannot be bracketed