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 import org.apache.commons.math.ode.nonstiff.EmbeddedRungeKuttaIntegrator; 026 027 /** This class is a step interpolator that does nothing. 028 * 029 * <p>This class is used when the {@link StepHandler "step handler"} 030 * set up by the user does not need step interpolation. It does not 031 * recompute the state when {@link AbstractStepInterpolator#setInterpolatedTime 032 * setInterpolatedTime} is called. This implies the interpolated state 033 * is always the state at the end of the current step.</p> 034 * 035 * @see StepHandler 036 * 037 * @version $Revision: 782431 $ $Date: 2009-06-07 15:04:37 -0400 (Sun, 07 Jun 2009) $ 038 * @since 1.2 039 */ 040 041 public class DummyStepInterpolator 042 extends AbstractStepInterpolator { 043 044 /** Simple constructor. 045 * This constructor builds an instance that is not usable yet, the 046 * <code>AbstractStepInterpolator.reinitialize</code> protected method 047 * should be called before using the instance in order to initialize 048 * the internal arrays. This constructor is used only in order to delay 049 * the initialization in some cases. As an example, the {@link 050 * EmbeddedRungeKuttaIntegrator} uses the prototyping design pattern 051 * to create the step interpolators by cloning an uninitialized 052 * model and latter initializing the copy. 053 */ 054 public DummyStepInterpolator() { 055 super(); 056 } 057 058 /** Simple constructor. 059 * @param y reference to the integrator array holding the state at 060 * the end of the step 061 * @param forward integration direction indicator 062 */ 063 public DummyStepInterpolator(final double[] y, final boolean forward) { 064 super(y, forward); 065 } 066 067 /** Copy constructor. 068 * @param interpolator interpolator to copy from. The copy is a deep 069 * copy: its arrays are separated from the original arrays of the 070 * instance 071 */ 072 public DummyStepInterpolator(final DummyStepInterpolator interpolator) { 073 super(interpolator); 074 } 075 076 /** Really copy the finalized instance. 077 * @return a copy of the finalized instance 078 */ 079 @Override 080 protected StepInterpolator doCopy() { 081 return new DummyStepInterpolator(this); 082 } 083 084 /** Compute the state at the interpolated time. 085 * In this class, this method does nothing: the interpolated state 086 * is always the state at the end of the current step. 087 * @param theta normalized interpolation abscissa within the step 088 * (theta is zero at the previous time step and one at the current time step) 089 * @param oneMinusThetaH time gap between the interpolated time and 090 * the current time 091 * @throws DerivativeException this exception is propagated to the caller if the 092 * underlying user function triggers one 093 */ 094 @Override 095 protected void computeInterpolatedStateAndDerivatives(final double theta, final double oneMinusThetaH) 096 throws DerivativeException { 097 System.arraycopy(currentState, 0, interpolatedState, 0, currentState.length); 098 } 099 100 /** Write the instance to an output channel. 101 * @param out output channel 102 * @exception IOException if the instance cannot be written 103 */ 104 @Override 105 public void writeExternal(final ObjectOutput out) 106 throws IOException { 107 // save the state of the base class 108 writeBaseExternal(out); 109 } 110 111 /** Read the instance from an input channel. 112 * @param in input channel 113 * @exception IOException if the instance cannot be read 114 */ 115 @Override 116 public void readExternal(final ObjectInput in) 117 throws IOException { 118 119 // read the base class 120 final double t = readBaseExternal(in); 121 122 // we can now set the interpolated time and state 123 setInterpolatedTime(t); 124 125 } 126 127 /** Serializable version identifier */ 128 private static final long serialVersionUID = 1708010296707839488L; 129 130 }