Class RungeKuttaFieldStepInterpolator<T extends RealFieldElement<T>>

    • Field Detail

      • field

        private final Field<T extends RealFieldElement<T>> field
        Field to which the time and state vector elements belong.
      • yDotK

        private final T extends RealFieldElement<T>[][] yDotK
        Slopes at the intermediate points.
    • Constructor Detail

      • RungeKuttaFieldStepInterpolator

        protected RungeKuttaFieldStepInterpolator​(Field<T> field,
                                                  boolean forward,
                                                  T[][] yDotK,
                                                  FieldODEStateAndDerivative<T> globalPreviousState,
                                                  FieldODEStateAndDerivative<T> globalCurrentState,
                                                  FieldODEStateAndDerivative<T> softPreviousState,
                                                  FieldODEStateAndDerivative<T> softCurrentState,
                                                  FieldEquationsMapper<T> mapper)
        Simple constructor.
        Parameters:
        field - field to which the time and state vector elements belong
        forward - integration direction indicator
        yDotK - slopes at the intermediate points
        globalPreviousState - start of the global step
        globalCurrentState - end of the global step
        softPreviousState - start of the restricted step
        softCurrentState - end of the restricted step
        mapper - equations mapper for the all equations
    • Method Detail

      • create

        protected abstract RungeKuttaFieldStepInterpolator<T> create​(Field<T> newField,
                                                                     boolean newForward,
                                                                     T[][] newYDotK,
                                                                     FieldODEStateAndDerivative<T> newGlobalPreviousState,
                                                                     FieldODEStateAndDerivative<T> newGlobalCurrentState,
                                                                     FieldODEStateAndDerivative<T> newSoftPreviousState,
                                                                     FieldODEStateAndDerivative<T> newSoftCurrentState,
                                                                     FieldEquationsMapper<T> newMapper)
        Create a new instance.
        Parameters:
        newField - field to which the time and state vector elements belong
        newForward - integration direction indicator
        newYDotK - slopes at the intermediate points
        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
      • previousStateLinearCombination

        protected final T[] previousStateLinearCombination​(T... coefficients)
        Compute a state by linear combination added to previous state.
        Parameters:
        coefficients - coefficients to apply to the method staged derivatives
        Returns:
        combined state
      • currentStateLinearCombination

        protected T[] currentStateLinearCombination​(T... coefficients)
        Compute a state by linear combination added to current state.
        Parameters:
        coefficients - coefficients to apply to the method staged derivatives
        Returns:
        combined state
      • derivativeLinearCombination

        protected T[] derivativeLinearCombination​(T... coefficients)
        Compute a state derivative by linear combination.
        Parameters:
        coefficients - coefficients to apply to the method staged derivatives
        Returns:
        combined state
      • combine

        private T[] combine​(T[] a,
                            T... coefficients)
        Linearly combine arrays.
        Parameters:
        a - array to add to
        coefficients - coefficients to apply to the method staged derivatives
        Returns:
        a itself, as a convenience for fluent API