View Javadoc
1   /*
2    * Licensed to the Hipparchus project under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The Hipparchus project licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      https://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.hipparchus.ode.nonstiff;
19  
20  import org.hipparchus.ode.EquationsMapper;
21  import org.hipparchus.ode.ODEStateAndDerivative;
22  import org.hipparchus.util.FastMath;
23  
24  
25  /**
26   * This class implements the Luther sixth order Runge-Kutta
27   * integrator for Ordinary Differential Equations.
28  
29   * <p>
30   * This method is described in H. A. Luther 1968 paper <a
31   * href="http://www.ams.org/journals/mcom/1968-22-102/S0025-5718-68-99876-1/S0025-5718-68-99876-1.pdf">
32   * An explicit Sixth-Order Runge-Kutta Formula</a>.
33   * </p>
34  
35   * <p>This method is an explicit Runge-Kutta method, its Butcher-array
36   * is the following one :</p>
37   * <pre>
38   *        0   |               0                     0                     0                     0                     0                     0
39   *        1   |               1                     0                     0                     0                     0                     0
40   *       1/2  |              3/8                   1/8                    0                     0                     0                     0
41   *       2/3  |              8/27                  2/27                  8/27                   0                     0                     0
42   *   (7-q)/14 | (  -21 +   9q)/392    (  -56 +   8q)/392    (  336 -  48q)/392    (  -63 +   3q)/392                  0                     0
43   *   (7+q)/14 | (-1155 - 255q)/1960   ( -280 -  40q)/1960   (    0 - 320q)/1960   (   63 + 363q)/1960   ( 2352 + 392q)/1960                 0
44   *        1   | (  330 + 105q)/180    (  120 +   0q)/180    ( -200 + 280q)/180    (  126 - 189q)/180    ( -686 - 126q)/180     ( 490 -  70q)/180
45   *            |--------------------------------------------------------------------------------------------------------------------------------------------------
46   *            |              1/20                   0                   16/45                  0                   49/180                 49/180         1/20
47   * </pre>
48   * <p>where q = &radic;21</p>
49   *
50   * @see EulerIntegrator
51   * @see ClassicalRungeKuttaIntegrator
52   * @see GillIntegrator
53   * @see MidpointIntegrator
54   * @see ThreeEighthesIntegrator
55   */
56  
57  public class LutherIntegrator extends RungeKuttaIntegrator {
58  
59      /** Name of integration scheme. */
60      public static final String METHOD_NAME = "Luther";
61  
62      /** Square root. */
63      private static final double Q = FastMath.sqrt(21);
64  
65      /** Simple constructor.
66       * Build a fourth-order Luther integrator with the given step.
67       * @param step integration step
68       */
69      public LutherIntegrator(final double step) {
70          super(METHOD_NAME, step);
71      }
72  
73      /** {@inheritDoc} */
74      @Override
75      public double[] getC() {
76          return new double[] {
77              1.0, 1.0 / 2.0, 2.0 / 3.0, (7.0 - Q) / 14.0, (7.0 + Q) / 14.0, 1.0
78          };
79      }
80  
81      /** {@inheritDoc} */
82      @Override
83      public double[][] getA() {
84          return new double[][] {
85              {                      1.0        },
86              {                   3.0 /   8.0,                  1.0 /   8.0  },
87              {                   8.0 /   27.0,                 2.0 /   27.0,                  8.0 /   27.0  },
88              { (  -21.0 +   9.0 * Q) /  392.0, ( -56.0 +  8.0 * Q) /  392.0, ( 336.0 -  48.0 * Q) /  392.0, (-63.0 +   3.0 * Q) /  392.0 },
89              { (-1155.0 - 255.0 * Q) / 1960.0, (-280.0 - 40.0 * Q) / 1960.0, (   0.0 - 320.0 * Q) / 1960.0, ( 63.0 + 363.0 * Q) / 1960.0,   (2352.0 + 392.0 * Q) / 1960.0 },
90              { (  330.0 + 105.0 * Q) /  180.0, ( 120.0 +  0.0 * Q) /  180.0, (-200.0 + 280.0 * Q) /  180.0, (126.0 - 189.0 * Q) /  180.0,   (-686.0 - 126.0 * Q) /  180.0,   (490.0 -  70.0 * Q) / 180.0 }
91          };
92      }
93  
94      /** {@inheritDoc} */
95      @Override
96      public double[] getB() {
97          return new double[] {
98              1.0 / 20.0, 0, 16.0 / 45.0, 0, 49.0 / 180.0, 49.0 / 180.0, 1.0 / 20.0
99          };
100     }
101 
102     /** {@inheritDoc} */
103     @Override
104     protected LutherStateInterpolator
105     createInterpolator(final boolean forward, double[][] yDotK,
106                        final ODEStateAndDerivative globalPreviousState,
107                        final ODEStateAndDerivative globalCurrentState,
108                        final EquationsMapper mapper) {
109         return new LutherStateInterpolator(forward, yDotK,
110                                           globalPreviousState, globalCurrentState,
111                                           globalPreviousState, globalCurrentState,
112                                           mapper);
113     }
114 
115 }