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