diff options
Diffstat (limited to 'src/main/java/org/apache/commons/math/ode/sampling/DummyStepInterpolator.java')
-rw-r--r-- | src/main/java/org/apache/commons/math/ode/sampling/DummyStepInterpolator.java | 150 |
1 files changed, 150 insertions, 0 deletions
diff --git a/src/main/java/org/apache/commons/math/ode/sampling/DummyStepInterpolator.java b/src/main/java/org/apache/commons/math/ode/sampling/DummyStepInterpolator.java new file mode 100644 index 0000000..af28c13 --- /dev/null +++ b/src/main/java/org/apache/commons/math/ode/sampling/DummyStepInterpolator.java @@ -0,0 +1,150 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.commons.math.ode.sampling; + +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +/** This class is a step interpolator that does nothing. + * + * <p>This class is used when the {@link StepHandler "step handler"} + * set up by the user does not need step interpolation. It does not + * recompute the state when {@link AbstractStepInterpolator#setInterpolatedTime + * setInterpolatedTime} is called. This implies the interpolated state + * is always the state at the end of the current step.</p> + * + * @see StepHandler + * + * @version $Revision: 1037327 $ $Date: 2010-11-20 21:57:37 +0100 (sam. 20 nov. 2010) $ + * @since 1.2 + */ + +public class DummyStepInterpolator + extends AbstractStepInterpolator { + + /** Serializable version identifier. */ + private static final long serialVersionUID = 1708010296707839488L; + + /** Current derivative. */ + private double[] currentDerivative; + + /** Simple constructor. + * This constructor builds an instance that is not usable yet, the + * <code>AbstractStepInterpolator.reinitialize</code> protected method + * should be called before using the instance in order to initialize + * the internal arrays. This constructor is used only in order to delay + * the initialization in some cases. As an example, the {@link + * org.apache.commons.math.ode.nonstiff.EmbeddedRungeKuttaIntegrator} uses + * the prototyping design pattern to create the step interpolators by + * cloning an uninitialized model and latter initializing the copy. + */ + public DummyStepInterpolator() { + super(); + currentDerivative = null; + } + + /** Simple constructor. + * @param y reference to the integrator array holding the state at + * the end of the step + * @param yDot reference to the integrator array holding the state + * derivative at some arbitrary point within the step + * @param forward integration direction indicator + */ + public DummyStepInterpolator(final double[] y, final double[] yDot, final boolean forward) { + super(y, forward); + currentDerivative = yDot; + } + + /** Copy constructor. + * @param interpolator interpolator to copy from. The copy is a deep + * copy: its arrays are separated from the original arrays of the + * instance + */ + public DummyStepInterpolator(final DummyStepInterpolator interpolator) { + super(interpolator); + currentDerivative = interpolator.currentDerivative.clone(); + } + + /** Really copy the finalized instance. + * @return a copy of the finalized instance + */ + @Override + protected StepInterpolator doCopy() { + return new DummyStepInterpolator(this); + } + + /** Compute the state at the interpolated time. + * In this class, this method does nothing: the interpolated state + * is always the state at the end of the current step. + * @param theta normalized interpolation abscissa within the step + * (theta is zero at the previous time step and one at the current time step) + * @param oneMinusThetaH time gap between the interpolated time and + * the current time + */ + @Override + protected void computeInterpolatedStateAndDerivatives(final double theta, final double oneMinusThetaH) { + System.arraycopy(currentState, 0, interpolatedState, 0, currentState.length); + System.arraycopy(currentDerivative, 0, interpolatedDerivatives, 0, currentDerivative.length); + } + + /** Write the instance to an output channel. + * @param out output channel + * @exception IOException if the instance cannot be written + */ + @Override + public void writeExternal(final ObjectOutput out) + throws IOException { + + // save the state of the base class + writeBaseExternal(out); + + if (currentDerivative != null) { + for (int i = 0; i < currentDerivative.length; ++i) { + out.writeDouble(currentDerivative[i]); + } + } + + } + + /** Read the instance from an input channel. + * @param in input channel + * @exception IOException if the instance cannot be read + */ + @Override + public void readExternal(final ObjectInput in) + throws IOException { + + // read the base class + final double t = readBaseExternal(in); + + if (currentState == null) { + currentDerivative = null; + } else { + currentDerivative = new double[currentState.length]; + for (int i = 0; i < currentDerivative.length; ++i) { + currentDerivative[i] = in.readDouble(); + } + } + + // we can now set the interpolated time and state + setInterpolatedTime(t); + + } + +} |