View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) 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 ASF 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    *      http://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.apache.commons.math4.legacy.ode.nonstiff;
19  
20  import org.apache.commons.math4.core.jdkmath.JdkMath;
21  
22  
23  /**
24   * This class implements the Luther sixth order Runge-Kutta
25   * integrator for Ordinary Differential Equations.
26  
27   * <p>
28   * This method is described in H. A. Luther 1968 paper <a
29   * href="http://www.ams.org/journals/mcom/1968-22-102/S0025-5718-68-99876-1/S0025-5718-68-99876-1.pdf">
30   * An explicit Sixth-Order Runge-Kutta Formula</a>.
31   * </p>
32  
33   * <p>This method is an explicit Runge-Kutta method, its Butcher-array
34   * is the following one :
35   * <pre>
36   *        0   |               0                     0                     0                     0                     0                     0
37   *        1   |               1                     0                     0                     0                     0                     0
38   *       1/2  |              3/8                   1/8                    0                     0                     0                     0
39   *       2/3  |              8/27                  2/27                  8/27                   0                     0                     0
40   *   (7-q)/14 | (  -21 +   9q)/392    (  -56 +   8q)/392    (  336 -  48q)/392    (  -63 +   3q)/392                  0                     0
41   *   (7+q)/14 | (-1155 - 255q)/1960   ( -280 -  40q)/1960   (    0 - 320q)/1960   (   63 + 363q)/1960   ( 2352 + 392q)/1960                 0
42   *        1   | (  330 + 105q)/180    (  120 +   0q)/180    ( -200 + 280q)/180    (  126 - 189q)/180    ( -686 - 126q)/180     ( 490 -  70q)/180
43   *            |--------------------------------------------------------------------------------------------------------------------------------------------------
44   *            |              1/20                   0                   16/45                  0                   49/180                 49/180         1/20
45   * </pre>
46   * where q = &radic;21
47   *
48   * @see EulerIntegrator
49   * @see ClassicalRungeKuttaIntegrator
50   * @see GillIntegrator
51   * @see MidpointIntegrator
52   * @see ThreeEighthesIntegrator
53   * @since 3.3
54   */
55  
56  public class LutherIntegrator extends RungeKuttaIntegrator {
57  
58      /** Square root. */
59      private static final double Q = JdkMath.sqrt(21);
60  
61      /** Time steps Butcher array. */
62      private static final double[] STATIC_C = {
63          1.0, 1.0 / 2.0, 2.0 / 3.0, (7.0 - Q) / 14.0, (7.0 + Q) / 14.0, 1.0
64      };
65  
66      /** Internal weights Butcher array. */
67      private static final double[][] STATIC_A = {
68          {                      1.0        },
69          {                   3.0 /   8.0,                  1.0 /   8.0  },
70          {                   8.0 /   27.0,                 2.0 /   27.0,                  8.0 /   27.0  },
71          { (  -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 },
72          { (-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 },
73          { (  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 }
74      };
75  
76      /** Propagation weights Butcher array. */
77      private static final double[] STATIC_B = {
78          1.0 / 20.0, 0, 16.0 / 45.0, 0, 49.0 / 180.0, 49.0 / 180.0, 1.0 / 20.0
79      };
80  
81      /** Simple constructor.
82       * Build a fourth-order Luther integrator with the given step.
83       * @param step integration step
84       */
85      public LutherIntegrator(final double step) {
86          super("Luther", STATIC_C, STATIC_A, STATIC_B, new LutherStepInterpolator(), step);
87      }
88  }