AbstractFieldStepInterpolator (Apache Commons Math 3.6.1 API)

org.apache.commons.math3.ode.sampling

## Class AbstractFieldStepInterpolator<T extends RealFieldElement<T>>

- java.lang.Object
- - org.apache.commons.math3.ode.sampling.AbstractFieldStepInterpolator<T>

- Type Parameters:
    `T` - the type of the field elements
  All Implemented Interfaces:
    FieldStepInterpolator<T>

      public abstract class AbstractFieldStepInterpolator<T extends RealFieldElement<T>>
      extends Object
      implements FieldStepInterpolator<T>

  This abstract class represents an interpolator over the last step during an ODE integration.

  The various ODE integrators provide objects extending this class to the step handlers. The handlers can use these objects to retrieve the state vector at intermediate times between the previous and the current grid points (dense output).

  Since:
    3.6
  See Also:
    `FirstOrderFieldIntegrator`, `StepHandler`

- - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---

    `protected`

    `AbstractFieldStepInterpolator(boolean isForward, FieldODEStateAndDerivative<T> globalPreviousState, FieldODEStateAndDerivative<T> globalCurrentState, FieldODEStateAndDerivative<T> softPreviousState, FieldODEStateAndDerivative<T> softCurrentState, FieldEquationsMapper<T> equationsMapper)`
    Simple constructor.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected abstract FieldODEStateAndDerivative<T>` | `computeInterpolatedStateAndDerivatives(FieldEquationsMapper<T> equationsMapper, T time, T theta, T thetaH, T oneMinusThetaH)` Compute the state and derivatives at the interpolated time.

    `protected abstract AbstractFieldStepInterpolator<T>`

    `create(boolean newForward, FieldODEStateAndDerivative<T> newGlobalPreviousState, FieldODEStateAndDerivative<T> newGlobalCurrentState, FieldODEStateAndDerivative<T> newSoftPreviousState, FieldODEStateAndDerivative<T> newSoftCurrentState, FieldEquationsMapper<T> newMapper)`
    Create a new instance.

    `FieldODEStateAndDerivative<T>` | `getCurrentState()` Get the state at current grid point time.
    `FieldODEStateAndDerivative<T>` | `getGlobalCurrentState()` Get the current global grid point state.
    `FieldODEStateAndDerivative<T>` | `getGlobalPreviousState()` Get the previous global grid point state.
    `FieldODEStateAndDerivative<T>` | `getInterpolatedState(T time)` Get the state at interpolated time.
    `FieldODEStateAndDerivative<T>` | `getPreviousState()` Get the state at previous grid point time.
    `boolean` | `isForward()` Check if the natural integration direction is forward.
    `AbstractFieldStepInterpolator<T>` | `restrictStep(FieldODEStateAndDerivative<T> previousState, FieldODEStateAndDerivative<T> currentState)` Create a new restricted version of the instance.

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

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

- - ### Constructor Detail

    - #### AbstractFieldStepInterpolator

          protected AbstractFieldStepInterpolator(boolean isForward,
                                       FieldODEStateAndDerivative<T> globalPreviousState,
                                       FieldODEStateAndDerivative<T> globalCurrentState,
                                       FieldODEStateAndDerivative<T> softPreviousState,
                                       FieldODEStateAndDerivative<T> softCurrentState,
                                       FieldEquationsMapper<T> equationsMapper)

      Simple constructor.
      Parameters:
        `isForward` - integration direction indicator
        `globalPreviousState` - start of the global step
        `globalCurrentState` - end of the global step
        `softPreviousState` - start of the restricted step
        `softCurrentState` - end of the restricted step
        `equationsMapper` - mapper for ODE equations primary and secondary components

  - ### Method Detail

    - #### restrictStep

          public AbstractFieldStepInterpolator<T> restrictStep(FieldODEStateAndDerivative<T> previousState,
                                                      FieldODEStateAndDerivative<T> currentState)

      Create a new restricted version of the instance.

      The instance is not changed at all.

      Parameters:
        `previousState` - start of the restricted step
        `currentState` - end of the restricted step
      Returns:
        restricted version of the instance
      See Also:
        `getPreviousState()`, `getCurrentState()`

    - #### create

          protected abstract AbstractFieldStepInterpolator<T> create(boolean newForward,
                                                FieldODEStateAndDerivative<T> newGlobalPreviousState,
                                                FieldODEStateAndDerivative<T> newGlobalCurrentState,
                                                FieldODEStateAndDerivative<T> newSoftPreviousState,
                                                FieldODEStateAndDerivative<T> newSoftCurrentState,
                                                FieldEquationsMapper<T> newMapper)

      Create a new instance.
      Parameters:
        `newForward` - integration direction indicator
        `newGlobalPreviousState` - start of the global step
        `newGlobalCurrentState` - end of the global step
        `newSoftPreviousState` - start of the restricted step
        `newSoftCurrentState` - end of the restricted step
        `newMapper` - equations mapper for the all equations
      Returns:
        a new instance

    - #### getGlobalPreviousState

          public FieldODEStateAndDerivative<T> getGlobalPreviousState()

      Get the previous global grid point state.
      Returns:
        previous global grid point state

    - #### getGlobalCurrentState

          public FieldODEStateAndDerivative<T> getGlobalCurrentState()

      Get the current global grid point state.
      Returns:
        current global grid point state

    - #### getPreviousState

          public FieldODEStateAndDerivative<T> getPreviousState()

      Get the state at previous grid point time.
      Specified by:
        `getPreviousState` in interface `FieldStepInterpolator<T extends RealFieldElement<T>>`
      Returns:
        state at previous grid point time

    - #### getCurrentState

          public FieldODEStateAndDerivative<T> getCurrentState()

      Get the state at current grid point time.
      Specified by:
        `getCurrentState` in interface `FieldStepInterpolator<T extends RealFieldElement<T>>`
      Returns:
        state at current grid point time

    - #### getInterpolatedState

          public FieldODEStateAndDerivative<T> getInterpolatedState(T time)

      Get the state at interpolated time.

      Setting the time outside of the current step is allowed, but should be used with care since the accuracy of the interpolator will probably be very poor far from this step. This allowance has been added to simplify implementation of search algorithms near the step endpoints.

      Specified by:
        `getInterpolatedState` in interface `FieldStepInterpolator<T extends RealFieldElement<T>>`
      Parameters:
        `time` - time of the interpolated point
      Returns:
        state at interpolated time

    - #### isForward

          public boolean isForward()

      Check if the natural integration direction is forward.

      This method provides the integration direction as specified by the integrator itself, it avoid some nasty problems in degenerated cases like null steps due to cancellation at step initialization, step control or discrete events triggering.

      Specified by:
        `isForward` in interface `FieldStepInterpolator<T extends RealFieldElement<T>>`
      Returns:
        true if the integration variable (time) increases during integration

    - #### computeInterpolatedStateAndDerivatives

          protected abstract FieldODEStateAndDerivative<T> computeInterpolatedStateAndDerivatives(FieldEquationsMapper<T> equationsMapper,
                                                                             T time,
                                                                             T theta,
                                                                             T thetaH,
                                                                             T oneMinusThetaH)
                                                                                                                       throws MaxCountExceededException

      Compute the state and derivatives at the interpolated time. This is the main processing method that should be implemented by the derived classes to perform the interpolation.
      Parameters:
        `equationsMapper` - mapper for ODE equations primary and secondary components
        `time` - interpolation time
        `theta` - normalized interpolation abscissa within the step (theta is zero at the previous time step and one at the current time step)
        `thetaH` - time gap between the previous time and the interpolated time
        `oneMinusThetaH` - time gap between the interpolated time and the current time
      Returns:
        interpolated state and derivatives
      Throws:
        `MaxCountExceededException` - if the number of functions evaluations is exceeded

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