001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018 package org.apache.commons.math.ode.sampling;
019
020 import java.io.IOException;
021 import java.io.ObjectInput;
022 import java.io.ObjectOutput;
023
024 import org.apache.commons.math.ode.DerivativeException;
025
026 /** This class is a step interpolator that does nothing.
027 *
028 * <p>This class is used when the {@link StepHandler "step handler"}
029 * set up by the user does not need step interpolation. It does not
030 * recompute the state when {@link AbstractStepInterpolator#setInterpolatedTime
031 * setInterpolatedTime} is called. This implies the interpolated state
032 * is always the state at the end of the current step.</p>
033 *
034 * @see StepHandler
035 *
036 * @version $Revision: 919479 $ $Date: 2010-03-05 11:35:56 -0500 (Fri, 05 Mar 2010) $
037 * @since 1.2
038 */
039
040 public class DummyStepInterpolator
041 extends AbstractStepInterpolator {
042
043 /** Serializable version identifier. */
044 private static final long serialVersionUID = 1708010296707839488L;
045
046 /** Current derivative. */
047 private double[] currentDerivative;
048
049 /** Simple constructor.
050 * This constructor builds an instance that is not usable yet, the
051 * <code>AbstractStepInterpolator.reinitialize</code> protected method
052 * should be called before using the instance in order to initialize
053 * the internal arrays. This constructor is used only in order to delay
054 * the initialization in some cases. As an example, the {@link
055 * org.apache.commons.math.ode.nonstiff.EmbeddedRungeKuttaIntegrator} uses
056 * the prototyping design pattern to create the step interpolators by
057 * cloning an uninitialized model and latter initializing the copy.
058 */
059 public DummyStepInterpolator() {
060 super();
061 currentDerivative = null;
062 }
063
064 /** Simple constructor.
065 * @param y reference to the integrator array holding the state at
066 * the end of the step
067 * @param yDot reference to the integrator array holding the state
068 * derivative at some arbitrary point within the step
069 * @param forward integration direction indicator
070 */
071 public DummyStepInterpolator(final double[] y, final double[] yDot, final boolean forward) {
072 super(y, forward);
073 currentDerivative = yDot;
074 }
075
076 /** Copy constructor.
077 * @param interpolator interpolator to copy from. The copy is a deep
078 * copy: its arrays are separated from the original arrays of the
079 * instance
080 */
081 public DummyStepInterpolator(final DummyStepInterpolator interpolator) {
082 super(interpolator);
083 currentDerivative = interpolator.currentDerivative.clone();
084 }
085
086 /** Really copy the finalized instance.
087 * @return a copy of the finalized instance
088 */
089 @Override
090 protected StepInterpolator doCopy() {
091 return new DummyStepInterpolator(this);
092 }
093
094 /** Compute the state at the interpolated time.
095 * In this class, this method does nothing: the interpolated state
096 * is always the state at the end of the current step.
097 * @param theta normalized interpolation abscissa within the step
098 * (theta is zero at the previous time step and one at the current time step)
099 * @param oneMinusThetaH time gap between the interpolated time and
100 * the current time
101 * @throws DerivativeException this exception is propagated to the caller if the
102 * underlying user function triggers one
103 */
104 @Override
105 protected void computeInterpolatedStateAndDerivatives(final double theta, final double oneMinusThetaH)
106 throws DerivativeException {
107 System.arraycopy(currentState, 0, interpolatedState, 0, currentState.length);
108 System.arraycopy(currentDerivative, 0, interpolatedDerivatives, 0, currentDerivative.length);
109 }
110
111 /** Write the instance to an output channel.
112 * @param out output channel
113 * @exception IOException if the instance cannot be written
114 */
115 @Override
116 public void writeExternal(final ObjectOutput out)
117 throws IOException {
118
119 // save the state of the base class
120 writeBaseExternal(out);
121
122 if (currentDerivative != null) {
123 for (int i = 0; i < currentDerivative.length; ++i) {
124 out.writeDouble(currentDerivative[i]);
125 }
126 }
127
128 }
129
130 /** Read the instance from an input channel.
131 * @param in input channel
132 * @exception IOException if the instance cannot be read
133 */
134 @Override
135 public void readExternal(final ObjectInput in)
136 throws IOException {
137
138 // read the base class
139 final double t = readBaseExternal(in);
140
141 if (currentState == null) {
142 currentDerivative = null;
143 } else {
144 currentDerivative = new double[currentState.length];
145 for (int i = 0; i < currentDerivative.length; ++i) {
146 currentDerivative[i] = in.readDouble();
147 }
148 }
149
150 // we can now set the interpolated time and state
151 setInterpolatedTime(t);
152
153 }
154
155 }