java.lang.Object
- org.hipparchus.ode.AbstractIntegrator
- - org.hipparchus.ode.nonstiff.AdaptiveStepsizeIntegrator
  - - org.hipparchus.ode.MultistepIntegrator

All Implemented Interfaces:

ODEIntegrator

Direct Known Subclasses:

AdamsIntegrator
```
public abstract class MultistepIntegrator
extends AdaptiveStepsizeIntegrator
```
This class is the base class for multistep integrators for Ordinary Differential Equations.
We define scaled derivatives s_i(n) at step n as:
```
 s₁(n) = h y'_n for first derivative
 s₂(n) = h²/2 y''_n for second derivative
 s₃(n) = h³/6 y'''_n for third derivative
 ...
 s_k(n) = h^k/k! y^(k)_n for k^th derivative
 
```
Rather than storing several previous steps separately, this 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:
```
 r_n = [ s₂(n), s₃(n) ... s_k(n) ]^T
 
```
(we omit the k index in the notation for clarity)

Multistep integrators with Nordsieck representation are highly sensitive to large step changes because when the step is multiplied by factor a, the k^th component of the Nordsieck vector is multiplied by a^k and the last components are the least accurate ones. The default max growth factor is therefore set to a quite low value: 2^1/order.
See Also:

AdamsBashforthIntegrator, AdamsMoultonIntegrator

Field Summary

Fields
Modifier and Type	Field	Description
`protected Array2DRowRealMatrix`	`nordsieck`	Nordsieck matrix of the higher scaled derivatives.
`protected double[]`	`scaled`	First scaled derivative (h y').

Fields inherited from class org.hipparchus.ode.nonstiff.AdaptiveStepsizeIntegrator
mainSetDimension, scalAbsoluteTolerance, scalRelativeTolerance, vecAbsoluteTolerance, vecRelativeTolerance

Constructor Summary

Constructors
Modifier	Constructor	Description
`protected`	`MultistepIntegrator(String name, int nSteps, int order, double minStep, double maxStep, double[] vecAbsoluteTolerance, double[] vecRelativeTolerance)`	Build a multistep integrator with the given stepsize bounds.
`protected`	`MultistepIntegrator(String name, int nSteps, int order, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance)`	Build a multistep integrator with the given stepsize bounds.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`protected double`	`computeStepGrowShrinkFactor(double error)`	Compute step grow/shrink factor according to normalized error.
`double`	`getMaxGrowth()`	Get the maximal growth factor for stepsize control.
`double`	`getMinReduction()`	Get the minimal reduction factor for stepsize control.
`int`	`getNSteps()`	Get the number of steps of the multistep method (excluding the one being computed).
`double`	`getSafety()`	Get the safety factor for stepsize control.
`ODEIntegrator`	`getStarterIntegrator()`	Get the starter integrator.
`protected abstract Array2DRowRealMatrix`	`initializeHighOrderDerivatives(double h, double[] t, double[][] y, double[][] yDot)`	Initialize the high order scaled derivatives at step start.
`protected void`	`rescale(double newStepSize)`	Rescale the instance.
`void`	`setMaxGrowth(double maxGrowth)`	Set the maximal growth factor for stepsize control.
`void`	`setMinReduction(double minReduction)`	Set the minimal reduction factor for stepsize control.
`void`	`setSafety(double safety)`	Set the safety factor for stepsize control.
`void`	`setStarterIntegrator(ODEIntegrator starterIntegrator)`	Set the starter integrator.
`protected void`	`start(ExpandableODE equations, ODEState initialState, double finalTime)`	Start the integration.

Methods inherited from class org.hipparchus.ode.nonstiff.AdaptiveStepsizeIntegrator
filterStep, getMaxStep, getMinStep, initializeStep, resetInternalState, sanityChecks, setInitialStepSize, setStepSizeControl, setStepSizeControl

Methods inherited from class org.hipparchus.ode.AbstractIntegrator
acceptStep, addEventHandler, addEventHandler, addStepHandler, clearEventHandlers, clearStepHandlers, computeDerivatives, getCurrentSignedStepsize, getCurrentStepStart, getEquations, getEvaluations, getEvaluationsCounter, getEventHandlers, getMaxEvaluations, getName, getStepHandlers, getStepSize, getStepStart, initIntegration, isLastStep, resetOccurred, setIsLastStep, setMaxEvaluations, setStateInitialized, setStepSize, setStepStart

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.hipparchus.ode.ODEIntegrator
integrate, integrate, integrate

- Field Detail
  - scaled
```
protected double[] scaled
```
    First scaled derivative (h y').
  - nordsieck
```
protected Array2DRowRealMatrix nordsieck
```
    Nordsieck matrix of the higher scaled derivatives.
    (h²/2 y'', h³/6 y''' ..., h^k/k! y^(k))
- Constructor Detail
  - MultistepIntegrator
```
protected MultistepIntegrator(String name,
                              int nSteps,
                              int order,
                              double minStep,
                              double maxStep,
                              double scalAbsoluteTolerance,
                              double scalRelativeTolerance)
                       throws MathIllegalArgumentException
```
    Build a multistep integrator with the given stepsize bounds.
    The default starter integrator is set to the Dormand-Prince 8(5,3) integrator with some defaults settings.
    
    The default max growth factor is set to a quite low value: 2^1/order.
    
    Parameters:
    
    name - name of the method
    
    nSteps - number of steps of the multistep method (excluding the one being computed)
    
    order - order of the method
    
    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:
    
    MathIllegalArgumentException - if number of steps is smaller than 2
  - MultistepIntegrator
```
protected MultistepIntegrator(String name,
                              int nSteps,
                              int order,
                              double minStep,
                              double maxStep,
                              double[] vecAbsoluteTolerance,
                              double[] vecRelativeTolerance)
```
    Build a multistep integrator with the given stepsize bounds.
    The default starter integrator is set to the Dormand-Prince 8(5,3) integrator with some defaults settings.
    
    The default max growth factor is set to a quite low value: 2^1/order.
    
    Parameters:
    
    name - name of the method
    
    nSteps - number of steps of the multistep method (excluding the one being computed)
    
    order - order of the method
    
    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
- Method Detail
  - getStarterIntegrator
```
public ODEIntegrator getStarterIntegrator()
```
    Get the starter integrator.
    
    Returns:
    
    starter integrator
  - setStarterIntegrator
```
public void setStarterIntegrator(ODEIntegrator starterIntegrator)
```
    Set the starter integrator.
    The various step and event handlers for this starter integrator will be managed automatically by the multi-step integrator. Any user configuration for these elements will be cleared before use.
    
    Parameters:
    
    starterIntegrator - starter integrator
  - start
```
protected void start(ExpandableODE equations,
                     ODEState initialState,
                     double finalTime)
              throws MathIllegalArgumentException,
                     MathIllegalStateException
```
    Start the integration.
    This method computes one step using the underlying starter integrator, and initializes the Nordsieck vector at step start. The starter integrator purpose is only to establish initial conditions, it does not really change time by itself. The top level multistep integrator remains in charge of handling time propagation and events handling as it will starts its own computation right from the beginning. In a sense, the starter integrator can be seen as a dummy one and so it will never trigger any user event nor call any user step handler.
    
    Parameters:
    
    equations - complete set of differential equations to integrate
    
    initialState - initial state (time, primary and secondary state vectors)
    
    finalTime - target time for the integration (can be set to a value smaller than initialState.getTime() for backward integration)
    
    Throws:
    
    MathIllegalArgumentException - if arrays dimension do not match equations settings
    
    MathIllegalArgumentException - if integration step is too small
    
    MathIllegalStateException - if the number of functions evaluations is exceeded
    
    MathIllegalArgumentException - if the location of an event cannot be bracketed
  - initializeHighOrderDerivatives
```
protected abstract Array2DRowRealMatrix initializeHighOrderDerivatives(double h,
                                                                       double[] t,
                                                                       double[][] y,
                                                                       double[][] yDot)
```
    Initialize the high order scaled derivatives at step start.
    
    Parameters:
    
    h - step size to use for scaling
    
    t - first steps times
    
    y - first steps states
    
    yDot - first steps derivatives
    
    Returns:
    
    Nordieck vector at first step (h²/2 y''_n, h³/6 y'''_n ... h^k/k! y^(k)_n)
  - getMinReduction
```
public double getMinReduction()
```
    Get the minimal reduction factor for stepsize control.
    
    Returns:
    
    minimal reduction factor
  - setMinReduction
```
public void setMinReduction(double minReduction)
```
    Set the minimal reduction factor for stepsize control.
    
    Parameters:
    
    minReduction - minimal reduction factor
  - getMaxGrowth
```
public double getMaxGrowth()
```
    Get the maximal growth factor for stepsize control.
    
    Returns:
    
    maximal growth factor
  - setMaxGrowth
```
public void setMaxGrowth(double maxGrowth)
```
    Set the maximal growth factor for stepsize control.
    
    Parameters:
    
    maxGrowth - maximal growth factor
  - getSafety
```
public double getSafety()
```
    Get the safety factor for stepsize control.
    
    Returns:
    
    safety factor
  - setSafety
```
public void setSafety(double safety)
```
    Set the safety factor for stepsize control.
    
    Parameters:
    
    safety - safety factor
  - getNSteps
```
public int getNSteps()
```
    Get the number of steps of the multistep method (excluding the one being computed).
    
    Returns:
    
    number of steps of the multistep method (excluding the one being computed)
  - rescale
```
protected void rescale(double newStepSize)
```
    Rescale the instance.
    Since the scaled and Nordsieck arrays are shared with the caller, this method has the side effect of rescaling this arrays in the caller too.
    
    Parameters:
    
    newStepSize - new step size to use in the scaled and Nordsieck arrays
  - computeStepGrowShrinkFactor
```
protected double computeStepGrowShrinkFactor(double error)
```
    Compute step grow/shrink factor according to normalized error.
    
    Parameters:
    
    error - normalized error of the current step
    
    Returns:
    
    grow/shrink factor for next step

Class MultistepIntegrator

Field Summary

Fields inherited from class org.hipparchus.ode.nonstiff.AdaptiveStepsizeIntegrator

Constructor Summary

Method Summary

Methods inherited from class org.hipparchus.ode.nonstiff.AdaptiveStepsizeIntegrator

Methods inherited from class org.hipparchus.ode.AbstractIntegrator

Methods inherited from class java.lang.Object

Methods inherited from interface org.hipparchus.ode.ODEIntegrator

Field Detail

scaled

nordsieck

Constructor Detail

MultistepIntegrator

MultistepIntegrator

Method Detail

getStarterIntegrator

setStarterIntegrator

start

initializeHighOrderDerivatives

getMinReduction

setMinReduction

getMaxGrowth

setMaxGrowth

getSafety

setSafety

getNSteps

rescale

computeStepGrowShrinkFactor