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.