org.apache.commons.math3.ode

## Class MultistepFieldIntegrator<T extends RealFieldElement<T>>

- java.lang.Object
- - org.apache.commons.math3.ode.AbstractFieldIntegrator<T>
  - - org.apache.commons.math3.ode.nonstiff.AdaptiveStepsizeFieldIntegrator<T>
    - - org.apache.commons.math3.ode.MultistepFieldIntegrator<T>

- Type Parameters:
    `T` - the type of the field elements
  All Implemented Interfaces:
    FirstOrderFieldIntegrator<T>
  Direct Known Subclasses:
    AdamsFieldIntegrator

      public abstract class MultistepFieldIntegrator<T extends RealFieldElement<T>>
      extends AdaptiveStepsizeFieldIntegrator<T>

  This class is the base class for multistep integrators for Ordinary Differential Equations.

  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

  Rather than storing several previous steps separately, this 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

  (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 kth component of the Nordsieck vector is multiplied by ak and the last components are the least accurate ones. The default max growth factor is therefore set to a quite low value: 21/order.

  Since:
    3.6
  See Also:
    `AdamsBashforthFieldIntegrator`, `AdamsMoultonFieldIntegrator`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Array2DRowFieldMatrix<T>` | `nordsieck` Nordsieck matrix of the higher scaled derivatives.
    `protected T[]` | `scaled` First scaled derivative (h y').

    - ### Fields inherited from class org.apache.commons.math3.ode.nonstiff.AdaptiveStepsizeFieldIntegrator

      `mainSetDimension, scalAbsoluteTolerance, scalRelativeTolerance, vecAbsoluteTolerance, vecRelativeTolerance`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `MultistepFieldIntegrator(Field<T> field, String name, int nSteps, int order, double minStep, double maxStep, double[] vecAbsoluteTolerance, double[] vecRelativeTolerance)` Build a multistep integrator with the given stepsize bounds.
    `protected` | `MultistepFieldIntegrator(Field<T> field, 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

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected T` | `computeStepGrowShrinkFactor(T 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.
    `FirstOrderFieldIntegrator<T>` | `getStarterIntegrator()` Get the starter integrator.
    `protected abstract Array2DRowFieldMatrix<T>` | `initializeHighOrderDerivatives(T h, T[] t, T[][] y, T[][] yDot)` Initialize the high order scaled derivatives at step start.
    `protected void` | `rescale(T 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(FirstOrderFieldIntegrator<T> starterIntegrator)` Set the starter integrator.
    `protected void` | `start(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T t)` Start the integration.

    - ### Methods inherited from class org.apache.commons.math3.ode.nonstiff.AdaptiveStepsizeFieldIntegrator

      `filterStep, getMaxStep, getMinStep, initializeStep, resetInternalState, sanityChecks, setInitialStepSize, setStepSizeControl, setStepSizeControl`

    - ### Methods inherited from class org.apache.commons.math3.ode.AbstractFieldIntegrator

      `acceptStep, 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, setStepStart`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.apache.commons.math3.ode.FirstOrderFieldIntegrator

      `integrate`

- - ### Field Detail

    - #### scaled

          protected T extends RealFieldElement<T>[] scaled

      First scaled derivative (h y').

    - #### nordsieck

          protected Array2DRowFieldMatrix<T extends RealFieldElement<T>> nordsieck

      Nordsieck matrix of the higher scaled derivatives.

      (h2/2 y'', h3/6 y''' ..., hk/k! y(k))

  - ### Constructor Detail

    - #### MultistepFieldIntegrator

          protected MultistepFieldIntegrator(Field<T> field,
                                  String name,
                                  int nSteps,
                                  int order,
                                  double minStep,
                                  double maxStep,
                                  double scalAbsoluteTolerance,
                                  double scalRelativeTolerance)
                                      throws NumberIsTooSmallException

      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: 21/order.

      Parameters:
        `field` - field to which the time and state vector elements belong
        `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:
        `NumberIsTooSmallException` - if number of steps is smaller than 2

    - #### MultistepFieldIntegrator

          protected MultistepFieldIntegrator(Field<T> field,
                                  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: 21/order.

      Parameters:
        `field` - field to which the time and state vector elements belong
        `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 FirstOrderFieldIntegrator<T> getStarterIntegrator()

      Get the starter integrator.
      Returns:
        starter integrator

    - #### setStarterIntegrator

          public void setStarterIntegrator(FirstOrderFieldIntegrator<T> 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(FieldExpandableODE<T> equations,
                   FieldODEState<T> initialState,
                   T t)
                        throws DimensionMismatchException,
                               NumberIsTooSmallException,
                               MaxCountExceededException,
                               NoBracketingException

      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)
        `t` - target time for the integration (can be set to a value smaller than `t0` for backward integration)
      Throws:
        `DimensionMismatchException` - if arrays dimension do not match equations settings
        `NumberIsTooSmallException` - if integration step is too small
        `MaxCountExceededException` - if the number of functions evaluations is exceeded
        `NoBracketingException` - if the location of an event cannot be bracketed

    - #### initializeHighOrderDerivatives

          protected abstract Array2DRowFieldMatrix<T> initializeHighOrderDerivatives(T h,
                                                                T[] t,
                                                                T[][] y,
                                                                T[][] 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 (h2/2 y''n, h3/6 y'''n ... hk/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(T 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 T computeStepGrowShrinkFactor(T 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

Copyright © 2003–2016 The Apache Software Foundation. All rights reserved.