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;
19
20 /**
21 * This class implements a step interpolator for second order
22 * Runge-Kutta integrator.
23 *
24 * <p>This interpolator allow to compute dense output inside the last
25 * step computed. The interpolation equation is consistent with the
26 * integration scheme :
27 *
28 * <pre>
29 * y(t_n + theta h) = y (t_n + h) + (1-theta) h [theta y'_1 - (1+theta) y'_2]
30 * </pre>
31 *
32 * where theta belongs to [0 ; 1] and where y'_1 and y'_2 are the two
33 * evaluations of the derivatives already computed during the
34 * step.</p>
35 *
36 * @see MidpointIntegrator
37 * @version $Revision: 620312 $ $Date: 2008-02-10 12:28:59 -0700 (Sun, 10 Feb 2008) $
38 * @since 1.2
39 */
40
41 class MidpointStepInterpolator
42 extends RungeKuttaStepInterpolator {
43
44 /** Simple constructor.
45 * This constructor builds an instance that is not usable yet, the
46 * {@link AbstractStepInterpolator#reinitialize} method should be called
47 * before using the instance in order to initialize the internal arrays. This
48 * constructor is used only in order to delay the initialization in
49 * some cases. The {@link RungeKuttaIntegrator} class uses the
50 * prototyping design pattern to create the step interpolators by
51 * cloning an uninitialized model and latter initializing the copy.
52 */
53 public MidpointStepInterpolator() {
54 }
55
56 /** Copy constructor.
57 * @param interpolator interpolator to copy from. The copy is a deep
58 * copy: its arrays are separated from the original arrays of the
59 * instance
60 */
61 public MidpointStepInterpolator(MidpointStepInterpolator interpolator) {
62 super(interpolator);
63 }
64
65 /** Really copy the finalized instance.
66 * @return a copy of the finalized instance
67 */
68 protected StepInterpolator doCopy() {
69 return new MidpointStepInterpolator(this);
70 }
71
72
73 /** Compute the state at the interpolated time.
74 * This is the main processing method that should be implemented by
75 * the derived classes to perform the interpolation.
76 * @param theta normalized interpolation abscissa within the step
77 * (theta is zero at the previous time step and one at the current time step)
78 * @param oneMinusThetaH time gap between the interpolated time and
79 * the current time
80 * @throws DerivativeException this exception is propagated to the caller if the
81 * underlying user function triggers one
82 */
83 protected void computeInterpolatedState(double theta,
84 double oneMinusThetaH)
85 throws DerivativeException {
86
87 double coeff1 = oneMinusThetaH * theta;
88 double coeff2 = oneMinusThetaH * (1.0 + theta);
89
90 for (int i = 0; i < interpolatedState.length; ++i) {
91 interpolatedState[i] = currentState[i] +
92 coeff1 * yDotK[0][i] - coeff2 * yDotK[1][i];
93 }
94
95 }
96
97 /** Serializable version identifier */
98 private static final long serialVersionUID = -865524111506042509L;
99
100 }