Class AdamsIntegrator

    • Constructor Detail

      • AdamsIntegrator

        public AdamsIntegrator​(String name,
                               int nSteps,
                               int order,
                               double minStep,
                               double maxStep,
                               double scalAbsoluteTolerance,
                               double scalRelativeTolerance)
                        throws MathIllegalArgumentException
        Build an Adams integrator with the given order and step control parameters.
        Parameters:
        name - name of the method
        nSteps - number of steps of the method excluding the one being computed
        order - order of the method
        minStep - minimal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
        maxStep - maximal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
        scalAbsoluteTolerance - allowed absolute error
        scalRelativeTolerance - allowed relative error
        Throws:
        MathIllegalArgumentException - if order is 1 or less
      • AdamsIntegrator

        public AdamsIntegrator​(String name,
                               int nSteps,
                               int order,
                               double minStep,
                               double maxStep,
                               double[] vecAbsoluteTolerance,
                               double[] vecRelativeTolerance)
                        throws IllegalArgumentException
        Build an Adams integrator with the given order and step control parameters.
        Parameters:
        name - name of the method
        nSteps - number of steps of the method excluding the one being computed
        order - order of the method
        minStep - minimal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
        maxStep - maximal step (sign is irrelevant, regardless of integration direction, forward or backward), the last step can be smaller than this
        vecAbsoluteTolerance - allowed absolute error
        vecRelativeTolerance - allowed relative error
        Throws:
        IllegalArgumentException - if order is 1 or less
    • Method Detail

      • integrate

        public ODEStateAndDerivative integrate​(ExpandableODE equations,
                                               ODEState initialState,
                                               double finalTime)
                                        throws MathIllegalArgumentException,
                                               MathIllegalStateException
        Integrate the differential equations up to the given time.

        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.

        Parameters:
        equations - 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 t0 for backward integration)
        Returns:
        final state, its time will be the same as finalTime if integration reached its target, but may be different if some ODEEventHandler stops it at some point.
        Throws:
        MathIllegalArgumentException - if integration step is too small
        MathIllegalStateException - if the number of functions evaluations is exceeded
      • initializeHighOrderDerivatives

        protected Array2DRowRealMatrix initializeHighOrderDerivatives​(double h,
                                                                      double[] t,
                                                                      double[][] y,
                                                                      double[][] yDot)
        Initialize the high order scaled derivatives at step start.
        Specified by:
        initializeHighOrderDerivatives in class MultistepIntegrator
        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)
      • updateHighOrderDerivativesPhase1

        public Array2DRowRealMatrix updateHighOrderDerivativesPhase1​(Array2DRowRealMatrix highOrder)
        Update the high order scaled derivatives for Adams integrators (phase 1).

        The complete update of high order derivatives has a form similar to: \[ r_{n+1} = (s_1(n) - s_1(n+1)) P^{-1} u + P^{-1} A P r_n \] this method computes the P-1 A P rn part.

        Parameters:
        highOrder - high order scaled derivatives (h2/2 y'', ... hk/k! y(k))
        Returns:
        updated high order derivatives
        See Also:
        updateHighOrderDerivativesPhase2(double[], double[], Array2DRowRealMatrix)
      • updateHighOrderDerivativesPhase2

        public void updateHighOrderDerivativesPhase2​(double[] start,
                                                     double[] end,
                                                     Array2DRowRealMatrix highOrder)
        Update the high order scaled derivatives Adams integrators (phase 2).

        The complete update of high order derivatives has a form similar to: \[ r_{n+1} = (s_1(n) - s_1(n+1)) P^{-1} u + P^{-1} A P r_n \] this method computes the (s1(n) - s1(n+1)) P-1 u part.

        Phase 1 of the update must already have been performed.

        Parameters:
        start - first order scaled derivatives at step start
        end - first order scaled derivatives at step end
        highOrder - high order scaled derivatives, will be modified (h2/2 y'', ... hk/k! y(k))
        See Also:
        updateHighOrderDerivativesPhase1(Array2DRowRealMatrix)
      • errorEstimation

        protected abstract double errorEstimation​(double[] previousState,
                                                  double predictedTime,
                                                  double[] predictedState,
                                                  double[] predictedScaled,
                                                  RealMatrix predictedNordsieck)
        Estimate error.
        Parameters:
        previousState - state vector at step start
        predictedTime - time at step end
        predictedState - predicted state vector at step end
        predictedScaled - predicted value of the scaled derivatives at step end
        predictedNordsieck - predicted value of the Nordsieck vector at step end
        Returns:
        estimated normalized local discretization error
        Since:
        2.0
      • finalizeStep

        protected abstract org.hipparchus.ode.nonstiff.AdamsStateInterpolator finalizeStep​(double stepSize,
                                                                                           double[] predictedState,
                                                                                           double[] predictedScaled,
                                                                                           Array2DRowRealMatrix predictedNordsieck,
                                                                                           boolean isForward,
                                                                                           ODEStateAndDerivative globalPreviousState,
                                                                                           ODEStateAndDerivative globalCurrentState,
                                                                                           EquationsMapper equationsMapper)
        Finalize the step.
        Parameters:
        stepSize - step size used in the scaled and Nordsieck arrays
        predictedState - predicted state at end of step
        predictedScaled - predicted first scaled derivative
        predictedNordsieck - predicted Nordsieck vector
        isForward - integration direction indicator
        globalPreviousState - start of the global step
        globalCurrentState - end of the global step
        equationsMapper - mapper for ODE equations primary and secondary components
        Returns:
        step interpolator
        Since:
        2.0