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.math.ode.nonstiff;
19
20 import org.apache.commons.math.ode.DerivativeException;
21 import org.apache.commons.math.ode.sampling.AbstractStepInterpolator;
22 import org.apache.commons.math.ode.sampling.StepInterpolator;
23
24 /**
25 * This class implements a step interpolator for second order
26 * Runge-Kutta integrator.
27 *
28 * <p>This interpolator computes dense output inside the last
29 * step computed. The interpolation equation is consistent with the
30 * integration scheme :
31 *
32 * <pre>
33 * y(t_n + theta h) = y (t_n + h) + (1-theta) h [theta y'_1 - (1+theta) y'_2]
34 * </pre>
35 *
36 * where theta belongs to [0 ; 1] and where y'_1 and y'_2 are the two
37 * evaluations of the derivatives already computed during the
38 * step.</p>
39 *
40 * @see MidpointIntegrator
41 * @version $Revision: 782432 $ $Date: 2009-06-07 15:08:26 -0400 (Sun, 07 Jun 2009) $
42 * @since 1.2
43 */
44
45 class MidpointStepInterpolator
46 extends RungeKuttaStepInterpolator {
47
48 /** Simple constructor.
49 * This constructor builds an instance that is not usable yet, the
50 * {@link AbstractStepInterpolator#reinitialize} method should be called
51 * before using the instance in order to initialize the internal arrays. This
52 * constructor is used only in order to delay the initialization in
53 * some cases. The {@link RungeKuttaIntegrator} class uses the
54 * prototyping design pattern to create the step interpolators by
55 * cloning an uninitialized model and latter initializing the copy.
56 */
57 public MidpointStepInterpolator() {
58 }
59
60 /** Copy constructor.
61 * @param interpolator interpolator to copy from. The copy is a deep
62 * copy: its arrays are separated from the original arrays of the
63 * instance
64 */
65 public MidpointStepInterpolator(final MidpointStepInterpolator interpolator) {
66 super(interpolator);
67 }
68
69 /** {@inheritDoc} */
70 @Override
71 protected StepInterpolator doCopy() {
72 return new MidpointStepInterpolator(this);
73 }
74
75
76 /** {@inheritDoc} */
77 @Override
78 protected void computeInterpolatedStateAndDerivatives(final double theta,
79 final double oneMinusThetaH)
80 throws DerivativeException {
81
82 final double coeff1 = oneMinusThetaH * theta;
83 final double coeff2 = oneMinusThetaH * (1.0 + theta);
84 final double coeffDot2 = 2 * theta;
85 final double coeffDot1 = 1 - coeffDot2;
86
87 for (int i = 0; i < interpolatedState.length; ++i) {
88 final double yDot1 = yDotK[0][i];
89 final double yDot2 = yDotK[1][i];
90 interpolatedState[i] = currentState[i] + coeff1 * yDot1 - coeff2 * yDot2;
91 interpolatedDerivatives[i] = coeffDot1 * yDot1 + coeffDot2 * yDot2;
92 }
93
94 }
95
96 /** Serializable version identifier */
97 private static final long serialVersionUID = -865524111506042509L;
98
99 }