Class LutherIntegrator

  • All Implemented Interfaces:
    ButcherArrayProvider, ODEIntegrator

    public class LutherIntegrator
    extends RungeKuttaIntegrator
    This class implements the Luther sixth order Runge-Kutta integrator for Ordinary Differential Equations.

    This method is described in H. A. Luther 1968 paper An explicit Sixth-Order Runge-Kutta Formula.

    This method is an explicit Runge-Kutta method, its Butcher-array is the following one :

            0   |               0                     0                     0                     0                     0                     0
            1   |               1                     0                     0                     0                     0                     0
           1/2  |              3/8                   1/8                    0                     0                     0                     0
           2/3  |              8/27                  2/27                  8/27                   0                     0                     0
       (7-q)/14 | (  -21 +   9q)/392    (  -56 +   8q)/392    (  336 -  48q)/392    (  -63 +   3q)/392                  0                     0
       (7+q)/14 | (-1155 - 255q)/1960   ( -280 -  40q)/1960   (    0 - 320q)/1960   (   63 + 363q)/1960   ( 2352 + 392q)/1960                 0
            1   | (  330 + 105q)/180    (  120 +   0q)/180    ( -200 + 280q)/180    (  126 - 189q)/180    ( -686 - 126q)/180     ( 490 -  70q)/180
                |--------------------------------------------------------------------------------------------------------------------------------------------------
                |              1/20                   0                   16/45                  0                   49/180                 49/180         1/20
     

    where q = √21

    See Also:
    EulerIntegrator, ClassicalRungeKuttaIntegrator, GillIntegrator, MidpointIntegrator, ThreeEighthesIntegrator
    • Constructor Detail

      • LutherIntegrator

        public LutherIntegrator​(double step)
        Simple constructor. Build a fourth-order Luther integrator with the given step.
        Parameters:
        step - integration step
    • Method Detail

      • getC

        public double[] getC()
        Get the time steps from Butcher array (without the first zero).
        Returns:
        time steps from Butcher array (without the first zero
      • getA

        public double[][] getA()
        Get the internal weights from Butcher array (without the first empty row).
        Returns:
        internal weights from Butcher array (without the first empty row)
      • getB

        public double[] getB()
        Get the external weights for the high order method from Butcher array.
        Returns:
        external weights for the high order method from Butcher array
      • createInterpolator

        protected org.hipparchus.ode.nonstiff.LutherStateInterpolator createInterpolator​(boolean forward,
                                                                                         double[][] yDotK,
                                                                                         ODEStateAndDerivative globalPreviousState,
                                                                                         ODEStateAndDerivative globalCurrentState,
                                                                                         EquationsMapper mapper)
        Create an interpolator.
        Specified by:
        createInterpolator in class RungeKuttaIntegrator
        Parameters:
        forward - integration direction indicator
        yDotK - slopes at the intermediate points
        globalPreviousState - start of the global step
        globalCurrentState - end of the global step
        mapper - equations mapper for the all equations
        Returns:
        external weights for the high order method from Butcher array