public class AdamsBashforthIntegrator extends AdamsIntegrator
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.
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 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 rnwhere 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 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 ]
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.
MultistepIntegrator.NordsieckTransformer| Constructor and Description |
|---|
AdamsBashforthIntegrator(int nSteps,
double minStep,
double maxStep,
double[] vecAbsoluteTolerance,
double[] vecRelativeTolerance)
Build an Adams-Bashforth integrator with the given order and step control parameters.
|
AdamsBashforthIntegrator(int nSteps,
double minStep,
double maxStep,
double scalAbsoluteTolerance,
double scalRelativeTolerance)
Build an Adams-Bashforth integrator with the given order and step control parameters.
|
| 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.
|
updateHighOrderDerivativesPhase1, updateHighOrderDerivativesPhase2getMaxGrowth, getMinReduction, getSafety, getStarterIntegrator, setMaxGrowth, setMinReduction, setSafety, setStarterIntegratorgetCurrentStepStart, getMaxStep, getMinStep, initializeStep, setInitialStepSizeaddEventHandler, addStepHandler, clearEventHandlers, clearStepHandlers, computeDerivatives, getCurrentSignedStepsize, getEvaluations, getEventHandlers, getMaxEvaluations, getName, getStepHandlers, setMaxEvaluationspublic AdamsBashforthIntegrator(int nSteps,
double minStep,
double maxStep,
double scalAbsoluteTolerance,
double scalRelativeTolerance)
throws java.lang.IllegalArgumentException
nSteps - number of steps of the method excluding the one being computedminStep - minimal step (must be positive even for backward
integration), the last step can be smaller than thismaxStep - maximal step (must be positive even for backward
integration)scalAbsoluteTolerance - allowed absolute errorscalRelativeTolerance - allowed relative errorjava.lang.IllegalArgumentException - if order is 1 or lesspublic AdamsBashforthIntegrator(int nSteps,
double minStep,
double maxStep,
double[] vecAbsoluteTolerance,
double[] vecRelativeTolerance)
throws java.lang.IllegalArgumentException
nSteps - number of steps of the method excluding the one being computedminStep - minimal step (must be positive even for backward
integration), the last step can be smaller than thismaxStep - maximal step (must be positive even for backward
integration)vecAbsoluteTolerance - allowed absolute errorvecRelativeTolerance - allowed relative errorjava.lang.IllegalArgumentException - if order is 1 or lesspublic double integrate(FirstOrderDifferentialEquations equations, double t0, double[] y0, double t, double[] y) throws DerivativeException, IntegratorException
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.
integrate in interface FirstOrderIntegratorintegrate in class AdamsIntegratorequations - differential equations to integratet0 - initial timey0 - initial value of the state vector at t0t - 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 y0EventHandler stops it at some point.DerivativeException - this exception is propagated to the caller if
the underlying user function triggers oneIntegratorException - if the integrator cannot perform integrationCopyright © 2010 - 2020 Adobe. All Rights Reserved