org.apache.commons.math.ode.nonstiff

Class AdamsMoultonIntegrator

java.lang.Object

org.apache.commons.math.ode.AbstractIntegrator

org.apache.commons.math.ode.nonstiff.AdaptiveStepsizeIntegrator

org.apache.commons.math.ode.MultistepIntegrator

org.apache.commons.math.ode.nonstiff.AdamsIntegrator

org.apache.commons.math.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 y_n+1,another method must be used to compute a first estimate of y_n+1, then compute y'_n+1, then compute a final estimate of y_n+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:

• k = 1: y_n+1 = y_n + h y'_n+1
• k = 2: y_n+1 = y_n + h (y'_n+1+y'_n)/2
• k = 3: y_n+1 = y_n + h (5y'_n+1+8y'_n-y'_n-1)/12
• k = 4: y_n+1 = y_n + h (9y'_n+1+19y'_n-5y'_n-1+y'_n-2)/24
• ...

A k-steps Adams-Moulton method is of order k+1.

Implementation details

We define scaled derivatives s_i(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:

• k = 1: y_n+1 = y_n + s₁(n+1)
• k = 2: y_n+1 = y_n + 1/2 s₁(n+1) + [ 1/2 ] q_n+1
• k = 3: y_n+1 = y_n + 5/12 s₁(n+1) + [ 8/12 -1/12 ] q_n+1
• k = 4: y_n+1 = y_n + 9/24 s₁(n+1) + [ 19/24 -5/24 1/24 ] q_n+1
• ...

Instead of using the classical representation with first derivatives only (y_n, s₁(n+1) and q_n+1), our implementation uses the Nordsieck vector with higher degrees scaled derivatives all taken at the same step (y_n, s₁(n) and r_n) where r_n 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, s₁(n-i) can be computed from s₁(n), s₂(n) ... s_k(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 r_n and q_n 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:

• it greatly simplifies step interpolation as the interpolator mainly applies Taylor series formulas,
• it simplifies step changes that occur when discrete events that truncate the step are triggered,
• it allows to extend the methods in order to support adaptive stepsize.

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

• Y_n+1 = y_n + s₁(n) + u^T r_n
• S₁(n+1) = h f(t_n+1, Y_n+1)
• R_n+1 = (s₁(n) - S₁(n+1)) P^-1 u + P^-1 A P r_n

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:

• y_n+1 = y_n + S₁(n+1) + [ -1 +1 -1 +1 ... ±1 ] r_n+1
• s₁(n+1) = h f(t_n+1, y_n+1)
• r_n+1 = R_n+1 + (s₁(n+1) - S₁(n+1)) P^-1 u

where the upper case Y_n+1, S₁(n+1) and R_n+1 represent the predicted states whereas the lower case y_n+1, s_n+1 and r_n+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

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.commons.math.ode.MultistepIntegrator

MultistepIntegrator.NordsieckTransformer

Constructor Summary

Constructors

Constructor and Description
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

Modifier and Type	Method and Description
double	integrate(FirstOrderDifferentialEquations equations, double t0, double[] y0, double t, double[] y) Integrate the differential equations up to the given time.

Methods inherited from class org.apache.commons.math.ode.nonstiff.AdamsIntegrator

updateHighOrderDerivativesPhase1, updateHighOrderDerivativesPhase2

Methods inherited from class org.apache.commons.math.ode.MultistepIntegrator

getMaxGrowth, getMinReduction, getSafety, getStarterIntegrator, setMaxGrowth, setMinReduction, setSafety, setStarterIntegrator

Methods inherited from class org.apache.commons.math.ode.nonstiff.AdaptiveStepsizeIntegrator

getCurrentStepStart, getMaxStep, getMinStep, initializeStep, setInitialStepSize

Methods inherited from class org.apache.commons.math.ode.AbstractIntegrator

addEventHandler, addStepHandler, clearEventHandlers, clearStepHandlers, computeDerivatives, getCurrentSignedStepsize, getEvaluations, getEventHandlers, getMaxEvaluations, getName, getStepHandlers, setMaxEvaluations

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AdamsMoultonIntegrator

public AdamsMoultonIntegrator(int nSteps,
                              double minStep,
                              double maxStep,
                              double scalAbsoluteTolerance,
                              double scalRelativeTolerance)
                       throws java.lang.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 (must be positive even for backward integration), the last step can be smaller than this

maxStep - maximal step (must be positive even for backward integration)

scalAbsoluteTolerance - allowed absolute error

scalRelativeTolerance - allowed relative error

Throws:

java.lang.IllegalArgumentException - if order is 1 or less

AdamsMoultonIntegrator

public AdamsMoultonIntegrator(int nSteps,
                              double minStep,
                              double maxStep,
                              double[] vecAbsoluteTolerance,
                              double[] vecRelativeTolerance)
                       throws java.lang.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 (must be positive even for backward integration), the last step can be smaller than this

maxStep - maximal step (must be positive even for backward integration)

vecAbsoluteTolerance - allowed absolute error

vecRelativeTolerance - allowed relative error

Throws:

java.lang.IllegalArgumentException - if order is 1 or less

Method Detail

integrate

public double integrate(FirstOrderDifferentialEquations equations,
                        double t0,
                        double[] y0,
                        double t,
                        double[] y)
                 throws DerivativeException,
                        IntegratorException

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 (ODEIntegrator.getCurrentSignedStepsize()), it is not thread-safe.

Specified by:

integrate in interface FirstOrderIntegrator

Specified by:

integrate in class AdamsIntegrator

Parameters:

equations - differential equations to integrate

t0 - initial time

y0 - initial value of the state vector at t0

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

y - placeholder where to put the state vector at each successful step (and hence at the end of integration), can be the same object as y0

Returns:

stop time, will be the same as target time if integration reached its target, but may be different if some EventHandler stops it at some point.

Throws:

DerivativeException - this exception is propagated to the caller if the underlying user function triggers one

IntegratorException - if the integrator cannot perform integration