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 }