org.apache.commons.math3.ode.nonstiff
Class AdamsMoultonIntegrator

java.lang.Object
  extended by org.apache.commons.math3.ode.AbstractIntegrator
      extended by org.apache.commons.math3.ode.nonstiff.AdaptiveStepsizeIntegrator
          extended by org.apache.commons.math3.ode.MultistepIntegrator
              extended by org.apache.commons.math3.ode.nonstiff.AdamsIntegrator
                  extended by org.apache.commons.math3.ode.nonstiff.AdamsMoultonIntegrator
All Implemented Interfaces:
FirstOrderIntegrator, ODEIntegrator

public class AdamsMoultonIntegrator
extends AdamsIntegrator

This class implements implicit Adams-Moulton integrators for Ordinary Differential Equations.

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.

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-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 j (-i)j-1 sj(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 (-i)j-1 terms:
        [  -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:

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 ]
 
From this predicted vector, the corrected vector is computed as follows: where the upper case Yn+1, S1(n+1) and Rn+1 represent the predicted states whereas the lower case yn+1, sn+1 and rn+1 represent the corrected states.

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:
2.0
Version:
$Id: AdamsMoultonIntegrator.java 1463684 2013-04-02 19:04:13Z luc $

Nested Class Summary
 
Nested classes/interfaces inherited from class org.apache.commons.math3.ode.MultistepIntegrator
MultistepIntegrator.NordsieckTransformer
 
Field Summary
 
Fields inherited from class org.apache.commons.math3.ode.MultistepIntegrator
nordsieck, scaled
 
Fields inherited from class org.apache.commons.math3.ode.nonstiff.AdaptiveStepsizeIntegrator
mainSetDimension, scalAbsoluteTolerance, scalRelativeTolerance, vecAbsoluteTolerance, vecRelativeTolerance
 
Fields inherited from class org.apache.commons.math3.ode.AbstractIntegrator
isLastStep, resetOccurred, stepHandlers, stepSize, stepStart
 
Constructor Summary
AdamsMoultonIntegrator(int nSteps, double minStep, double maxStep, double[] vecAbsoluteTolerance, double[] vecRelativeTolerance)
          Build an Adams-Moulton integrator with the given order and error control parameters.
AdamsMoultonIntegrator(int nSteps, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance)
          Build an Adams-Moulton integrator with the given order and error control parameters.
 
Method Summary
 void integrate(ExpandableStatefulODE equations, double t)
          Integrate a set of differential equations up to the given time.
 
Methods inherited from class org.apache.commons.math3.ode.nonstiff.AdamsIntegrator
initializeHighOrderDerivatives, updateHighOrderDerivativesPhase1, updateHighOrderDerivativesPhase2
 
Methods inherited from class org.apache.commons.math3.ode.MultistepIntegrator
computeStepGrowShrinkFactor, getMaxGrowth, getMinReduction, getSafety, getStarterIntegrator, setMaxGrowth, setMinReduction, setSafety, setStarterIntegrator, start
 
Methods inherited from class org.apache.commons.math3.ode.nonstiff.AdaptiveStepsizeIntegrator
filterStep, getCurrentStepStart, getMaxStep, getMinStep, initializeStep, resetInternalState, sanityChecks, setInitialStepSize, setStepSizeControl, setStepSizeControl
 
Methods inherited from class org.apache.commons.math3.ode.AbstractIntegrator
acceptStep, addEventHandler, addEventHandler, addStepHandler, clearEventHandlers, clearStepHandlers, computeDerivatives, getCurrentSignedStepsize, getEvaluations, getEvaluationsCounter, getEventHandlers, getExpandable, getMaxEvaluations, getName, getStepHandlers, initIntegration, integrate, setEquations, setMaxEvaluations, setStateInitialized
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

AdamsMoultonIntegrator

public AdamsMoultonIntegrator(int nSteps,
                              double minStep,
                              double maxStep,
                              double scalAbsoluteTolerance,
                              double scalRelativeTolerance)
                       throws NumberIsTooSmallException
Build an Adams-Moulton integrator with the given order and error control parameters.

Parameters:
nSteps - number of steps of the method excluding the one being computed
minStep - minimal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
maxStep - maximal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
scalAbsoluteTolerance - allowed absolute error
scalRelativeTolerance - allowed relative error
Throws:
NumberIsTooSmallException - if order is 1 or less

AdamsMoultonIntegrator

public AdamsMoultonIntegrator(int nSteps,
                              double minStep,
                              double maxStep,
                              double[] vecAbsoluteTolerance,
                              double[] vecRelativeTolerance)
                       throws IllegalArgumentException
Build an Adams-Moulton integrator with the given order and error control parameters.

Parameters:
nSteps - number of steps of the method excluding the one being computed
minStep - minimal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
maxStep - maximal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
vecAbsoluteTolerance - allowed absolute error
vecRelativeTolerance - allowed relative error
Throws:
IllegalArgumentException - if order is 1 or less
Method Detail

integrate

public void integrate(ExpandableStatefulODE equations,
                      double t)
               throws NumberIsTooSmallException,
                      DimensionMismatchException,
                      MaxCountExceededException,
                      NoBracketingException
Integrate a set of differential equations up to the given time.

This method solves an Initial Value Problem (IVP).

The set of differential equations is composed of a main set, which can be extended by some sets of secondary equations. The set of equations must be already set up with initial time and partial states. At integration completion, the final time and partial states will be available in the same object.

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

Specified by:
integrate in class AdamsIntegrator
Parameters:
equations - complete set of differential equations to integrate
t - target time for the integration (can be set to a value smaller than t0 for backward integration)
Throws:
NumberIsTooSmallException - if integration step is too small
DimensionMismatchException - if the dimension of the complete state does not match the complete equations sets dimension
MaxCountExceededException - if the number of functions evaluations is exceeded
NoBracketingException - if the location of an event cannot be bracketed


Copyright © 2003-2013 The Apache Software Foundation. All Rights Reserved.