T - the type of the field elementspublic class AdamsMoultonFieldIntegrator<T extends RealFieldElement<T>> extends AdamsFieldIntegrator<T>
Adams-Moulton methods (in fact due to Adams alone) are implicit 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+1, n, n-1 ... Since y'n+1 is needed to compute yn+1, another method must be used to compute a first estimate of yn+1, then compute y'n+1, then compute a final estimate of yn+1 using the following formulas. Depending on the number k of previous steps one wants to use for computing the next value, different formulas are available for the final estimate:
A k-steps Adams-Moulton method is of order k+1.
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-Moulton methods can be written:
Instead of using the classical representation with first derivatives only (yn, s1(n+1) and qn+1), 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 rnwhere 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 predicted Nordsieck vector at step n+1 is computed from the Nordsieck vector at step n as follows:
[ 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 ]
From this predicted vector, the corrected vector is computed as follows:
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.
nordsieck, scaledmainSetDimension, scalAbsoluteTolerance, scalRelativeTolerance, vecAbsoluteTolerance, vecRelativeTolerance| Constructor and Description |
|---|
AdamsMoultonFieldIntegrator(Field<T> field,
int nSteps,
double minStep,
double maxStep,
double[] vecAbsoluteTolerance,
double[] vecRelativeTolerance)
Build an Adams-Moulton integrator with the given order and error control parameters.
|
AdamsMoultonFieldIntegrator(Field<T> field,
int nSteps,
double minStep,
double maxStep,
double scalAbsoluteTolerance,
double scalRelativeTolerance)
Build an Adams-Moulton integrator with the given order and error control parameters.
|
| Modifier and Type | Method and Description |
|---|---|
FieldODEStateAndDerivative<T> |
integrate(FieldExpandableODE<T> equations,
FieldODEState<T> initialState,
T finalTime)
Integrate the differential equations up to the given time.
|
initializeHighOrderDerivatives, updateHighOrderDerivativesPhase1, updateHighOrderDerivativesPhase2computeStepGrowShrinkFactor, getMaxGrowth, getMinReduction, getNSteps, getSafety, getStarterIntegrator, rescale, setMaxGrowth, setMinReduction, setSafety, setStarterIntegrator, startfilterStep, getMaxStep, getMinStep, initializeStep, resetInternalState, sanityChecks, setInitialStepSize, setStepSizeControl, setStepSizeControlacceptStep, addEventHandler, addEventHandler, addStepHandler, clearEventHandlers, clearStepHandlers, computeDerivatives, getCurrentSignedStepsize, getCurrentStepStart, getEquations, getEvaluations, getEvaluationsCounter, getEventHandlers, getField, getMaxEvaluations, getName, getStepHandlers, getStepSize, getStepStart, initIntegration, isLastStep, resetOccurred, setIsLastStep, setMaxEvaluations, setStateInitialized, setStepSize, setStepStartpublic AdamsMoultonFieldIntegrator(Field<T> field, int nSteps, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance) throws NumberIsTooSmallException
field - field to which the time and state vector elements belongnSteps - number of steps of the method excluding the one being computedminStep - minimal step (sign is irrelevant, regardless of
integration direction, forward or backward), the last step can
be smaller than thismaxStep - maximal step (sign is irrelevant, regardless of
integration direction, forward or backward), the last step can
be smaller than thisscalAbsoluteTolerance - allowed absolute errorscalRelativeTolerance - allowed relative errorNumberIsTooSmallException - if order is 1 or lesspublic AdamsMoultonFieldIntegrator(Field<T> field, int nSteps, double minStep, double maxStep, double[] vecAbsoluteTolerance, double[] vecRelativeTolerance) throws IllegalArgumentException
field - field to which the time and state vector elements belongnSteps - number of steps of the method excluding the one being computedminStep - minimal step (sign is irrelevant, regardless of
integration direction, forward or backward), the last step can
be smaller than thismaxStep - maximal step (sign is irrelevant, regardless of
integration direction, forward or backward), the last step can
be smaller than thisvecAbsoluteTolerance - allowed absolute errorvecRelativeTolerance - allowed relative errorIllegalArgumentException - if order is 1 or lesspublic FieldODEStateAndDerivative<T> integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime) throws NumberIsTooSmallException, DimensionMismatchException, MaxCountExceededException, NoBracketingException
This method solves an Initial Value Problem (IVP).
Since this method stores some internal state variables made
available in its public interface during integration (FirstOrderFieldIntegrator.getCurrentSignedStepsize()), it is not thread-safe.
integrate in interface FirstOrderFieldIntegrator<T extends RealFieldElement<T>>integrate in class AdamsFieldIntegrator<T extends RealFieldElement<T>>equations - differential equations to integrateinitialState - initial state (time, primary and secondary state vectors)finalTime - target time for the integration
(can be set to a value smaller than t0 for backward integration)finalTime if
integration reached its target, but may be different if some FieldEventHandler stops it at some point.NumberIsTooSmallException - if integration step is too smallMaxCountExceededException - if the number of functions evaluations is exceededNoBracketingException - if the location of an event cannot be bracketedDimensionMismatchExceptionCopyright © 2003–2016 The Apache Software Foundation. All rights reserved.