public abstract class AbstractStepInterpolator extends Object implements StepInterpolator
The various ODE integrators provide objects extending this class to the step handlers. The handlers can use these objects to retrieve the state vector at intermediate times between the previous and the current grid points (dense output).
FirstOrderIntegrator, 
SecondOrderIntegrator, 
StepHandler, 
Serialized Form| Modifier and Type | Field and Description | 
|---|---|
| protected double[] | currentStatecurrent state | 
| protected double | hcurrent time step | 
| protected double[] | interpolatedDerivativesinterpolated derivatives | 
| protected double[] | interpolatedPrimaryDerivativesinterpolated primary derivatives | 
| protected double[] | interpolatedPrimaryStateinterpolated primary state | 
| protected double[][] | interpolatedSecondaryDerivativesinterpolated secondary derivatives | 
| protected double[][] | interpolatedSecondaryStateinterpolated secondary state | 
| protected double[] | interpolatedStateinterpolated state | 
| protected double | interpolatedTimeinterpolated time | 
| Modifier | Constructor and Description | 
|---|---|
| protected  | AbstractStepInterpolator()Simple constructor. | 
| protected  | AbstractStepInterpolator(AbstractStepInterpolator interpolator)Copy constructor. | 
| protected  | AbstractStepInterpolator(double[] y,
                        boolean forward,
                        EquationsMapper primaryMapper,
                        EquationsMapper[] secondaryMappers)Simple constructor. | 
| Modifier and Type | Method and Description | 
|---|---|
| protected abstract void | computeInterpolatedStateAndDerivatives(double theta,
                                      double oneMinusThetaH)Compute the state and derivatives at the interpolated time. | 
| StepInterpolator | copy()Copy the instance. | 
| protected abstract StepInterpolator | doCopy()Really copy the finalized instance. | 
| protected void | doFinalize()Really finalize the step. | 
| void | finalizeStep()Finalize the step. | 
| double | getCurrentTime()Get the current soft grid point time. | 
| double | getGlobalCurrentTime()Get the current global grid point time. | 
| double | getGlobalPreviousTime()Get the previous global grid point time. | 
| double[] | getInterpolatedDerivatives()Get the derivatives of the state vector of the interpolated point. | 
| double[] | getInterpolatedSecondaryDerivatives(int index)Get the interpolated secondary derivatives corresponding to the secondary equations. | 
| double[] | getInterpolatedSecondaryState(int index)Get the interpolated secondary state corresponding to the secondary equations. | 
| double[] | getInterpolatedState()Get the state vector of the interpolated point. | 
| double | getInterpolatedTime()Get the time of the interpolated point. | 
| double | getPreviousTime()Get the previous soft grid point time. | 
| boolean | isForward()Check if the natural integration direction is forward. | 
| protected double | readBaseExternal(ObjectInput in)Read the base state of the instance. | 
| abstract void | readExternal(ObjectInput in) | 
| protected void | reinitialize(double[] y,
            boolean isForward,
            EquationsMapper primary,
            EquationsMapper[] secondary)Reinitialize the instance | 
| void | setInterpolatedTime(double time)Set the time of the interpolated point. | 
| void | setSoftCurrentTime(double softCurrentTime)Restrict step range to a limited part of the global step. | 
| void | setSoftPreviousTime(double softPreviousTime)Restrict step range to a limited part of the global step. | 
| void | shift()Shift one step forward. | 
| void | storeTime(double t)Store the current step time. | 
| protected void | writeBaseExternal(ObjectOutput out)Save the base state of the instance. | 
| abstract void | writeExternal(ObjectOutput out) | 
protected double h
protected double[] currentState
protected double interpolatedTime
protected double[] interpolatedState
protected double[] interpolatedDerivatives
protected double[] interpolatedPrimaryState
protected double[] interpolatedPrimaryDerivatives
protected double[][] interpolatedSecondaryState
protected double[][] interpolatedSecondaryDerivatives
protected AbstractStepInterpolator()
reinitialize(double[], boolean, org.apache.commons.math3.ode.EquationsMapper, org.apache.commons.math3.ode.EquationsMapper[]) 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 EmbeddedRungeKuttaIntegrator
 class uses the prototyping design pattern to create the step
 interpolators by cloning an uninitialized model and latter
 initializing the copy.protected AbstractStepInterpolator(double[] y,
                        boolean forward,
                        EquationsMapper primaryMapper,
                        EquationsMapper[] secondaryMappers)
y - reference to the integrator array holding the state at
 the end of the stepforward - integration direction indicatorprimaryMapper - equations mapper for the primary equations setsecondaryMappers - equations mappers for the secondary equations setsprotected AbstractStepInterpolator(AbstractStepInterpolator interpolator)
The copied interpolator should have been finalized before the
 copy, otherwise the copy will not be able to perform correctly
 any derivative computation and will throw a NullPointerException later. Since we don't want this constructor
 to throw the exceptions finalization may involve and since we
 don't want this method to modify the state of the copied
 interpolator, finalization is not done
 automatically, it remains under user control.
The copy is a deep copy: its arrays are separated from the original arrays of the instance.
interpolator - interpolator to copy from.protected void reinitialize(double[] y,
                boolean isForward,
                EquationsMapper primary,
                EquationsMapper[] secondary)
y - reference to the integrator array holding the state at the end of the stepisForward - integration direction indicatorprimary - equations mapper for the primary equations setsecondary - equations mappers for the secondary equations setspublic StepInterpolator copy() throws MaxCountExceededException
The copied instance is guaranteed to be independent from the original one. Both can be used with different settings for interpolated time without any side effect.
copy in interface StepInterpolatorMaxCountExceededException - if the number of functions evaluations is exceeded
 during step finalizationStepInterpolator.setInterpolatedTime(double)protected abstract StepInterpolator doCopy()
This method is called by copy() after the
 step has been finalized. It must perform a deep copy
 to have an new instance completely independent for the
 original instance.
public void shift()
storeTimepublic void storeTime(double t)
t - current timepublic void setSoftPreviousTime(double softPreviousTime)
 This method can be used to restrict a step and make it appear
 as if the original step was smaller. Calling this method
 only changes the value returned by getPreviousTime(),
 it does not change any other property
 
softPreviousTime - start of the restricted steppublic void setSoftCurrentTime(double softCurrentTime)
 This method can be used to restrict a step and make it appear
 as if the original step was smaller. Calling this method
 only changes the value returned by getCurrentTime(),
 it does not change any other property
 
softCurrentTime - end of the restricted steppublic double getGlobalPreviousTime()
public double getGlobalCurrentTime()
public double getPreviousTime()
getPreviousTime in interface StepInterpolatorsetSoftPreviousTime(double)public double getCurrentTime()
getCurrentTime in interface StepInterpolatorsetSoftCurrentTime(double)public double getInterpolatedTime()
StepInterpolator.setInterpolatedTime(double) has not been called, it returns
 the current grid point time.getInterpolatedTime in interface StepInterpolatorpublic void setInterpolatedTime(double time)
Setting the time outside of the current step is now allowed, but should be used with care since the accuracy of the interpolator will probably be very poor far from this step. This allowance has been added to simplify implementation of search algorithms near the step endpoints.
Setting the time changes the instance internal state. This includes
 the internal arrays returned in StepInterpolator.getInterpolatedState(),
 StepInterpolator.getInterpolatedDerivatives(), StepInterpolator.getInterpolatedSecondaryState(int) and StepInterpolator.getInterpolatedSecondaryDerivatives(int). So if their content must be preserved
 across several calls, user must copy them.
setInterpolatedTime in interface StepInterpolatortime - time of the interpolated pointStepInterpolator.getInterpolatedState(), 
StepInterpolator.getInterpolatedDerivatives(), 
StepInterpolator.getInterpolatedSecondaryState(int), 
StepInterpolator.getInterpolatedSecondaryDerivatives(int)public boolean isForward()
This method provides the integration direction as specified by the integrator itself, it avoid some nasty problems in degenerated cases like null steps due to cancellation at step initialization, step control or discrete events triggering.
isForward in interface StepInterpolatorprotected abstract void computeInterpolatedStateAndDerivatives(double theta,
                                          double oneMinusThetaH)
                                                        throws MaxCountExceededException
theta - normalized interpolation abscissa within the step
 (theta is zero at the previous time step and one at the current time step)oneMinusThetaH - time gap between the interpolated time and
 the current timeMaxCountExceededException - if the number of functions evaluations is exceededpublic double[] getInterpolatedState()
                              throws MaxCountExceededException
The returned vector is a reference to a reused array, so
 it should not be modified and it should be copied if it needs
 to be preserved across several calls to the associated
 StepInterpolator.setInterpolatedTime(double) method.
getInterpolatedState in interface StepInterpolatorStepInterpolator.getInterpolatedTime()MaxCountExceededException - if the number of functions evaluations is exceededStepInterpolator.getInterpolatedDerivatives(), 
StepInterpolator.getInterpolatedSecondaryState(int), 
StepInterpolator.getInterpolatedSecondaryDerivatives(int), 
StepInterpolator.setInterpolatedTime(double)public double[] getInterpolatedDerivatives()
                                    throws MaxCountExceededException
The returned vector is a reference to a reused array, so
 it should not be modified and it should be copied if it needs
 to be preserved across several calls to the associated
 StepInterpolator.setInterpolatedTime(double) method.
getInterpolatedDerivatives in interface StepInterpolatorStepInterpolator.getInterpolatedTime()MaxCountExceededException - if the number of functions evaluations is exceededStepInterpolator.getInterpolatedState(), 
StepInterpolator.getInterpolatedSecondaryState(int), 
StepInterpolator.getInterpolatedSecondaryDerivatives(int), 
StepInterpolator.setInterpolatedTime(double)public double[] getInterpolatedSecondaryState(int index)
                                       throws MaxCountExceededException
The returned vector is a reference to a reused array, so
 it should not be modified and it should be copied if it needs
 to be preserved across several calls to the associated
 StepInterpolator.setInterpolatedTime(double) method.
getInterpolatedSecondaryState in interface StepInterpolatorindex - index of the secondary set, as returned by ExpandableStatefulODE.addSecondaryEquations(SecondaryEquations)MaxCountExceededException - if the number of functions evaluations is exceededStepInterpolator.getInterpolatedState(), 
StepInterpolator.getInterpolatedDerivatives(), 
StepInterpolator.getInterpolatedSecondaryDerivatives(int), 
StepInterpolator.setInterpolatedTime(double)public double[] getInterpolatedSecondaryDerivatives(int index)
                                             throws MaxCountExceededException
The returned vector is a reference to a reused array, so it should not be modified and it should be copied if it needs to be preserved across several calls.
getInterpolatedSecondaryDerivatives in interface StepInterpolatorindex - index of the secondary set, as returned by ExpandableStatefulODE.addSecondaryEquations(SecondaryEquations)MaxCountExceededException - if the number of functions evaluations is exceededStepInterpolator.getInterpolatedState(), 
StepInterpolator.getInterpolatedDerivatives(), 
StepInterpolator.getInterpolatedSecondaryState(int), 
StepInterpolator.setInterpolatedTime(double)public final void finalizeStep()
                        throws MaxCountExceededException
Some embedded Runge-Kutta integrators need fewer functions
 evaluations than their counterpart step interpolators. These
 interpolators should perform the last evaluations they need by
 themselves only if they need them. This method triggers these
 extra evaluations. It can be called directly by the user step
 handler and it is called automatically if setInterpolatedTime(double) is called.
Once this method has been called, no other evaluation will be performed on this step. If there is a need to have some side effects between the step handler and the differential equations (for example update some data in the equations once the step has been done), it is advised to call this method explicitly from the step handler before these side effects are set up. If the step handler induces no side effect, then this method can safely be ignored, it will be called transparently as needed.
Warning: since the step interpolator provided
 to the step handler as a parameter of the handleStep is valid only for the duration
 of the handleStep call, one cannot
 simply store a reference and reuse it later. One should first
 finalize the instance, then copy this finalized instance into a
 new object that can be kept.
This method calls the protected doFinalize method
 if it has never been called during this step and set a flag
 indicating that it has been called once. It is the 
 doFinalize method which should perform the evaluations.
 This wrapping prevents from calling doFinalize several
 times and hence evaluating the differential equations too often.
 Therefore, subclasses are not allowed not reimplement it, they
 should rather reimplement doFinalize.
MaxCountExceededException - if the number of functions evaluations is exceededprotected void doFinalize()
                   throws MaxCountExceededException
MaxCountExceededException - if the number of functions evaluations is exceededpublic abstract void writeExternal(ObjectOutput out) throws IOException
writeExternal in interface ExternalizableIOExceptionpublic abstract void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
readExternal in interface ExternalizableIOExceptionClassNotFoundExceptionprotected void writeBaseExternal(ObjectOutput out) throws IOException
out - stream where to save the stateIOException - in case of write errorprotected double readBaseExternal(ObjectInput in) throws IOException, ClassNotFoundException
setInterpolatedTime(double) method later,
 once all rest of the object state has been set up properly.in - stream where to read the state fromIOException - in case of read errorClassNotFoundException - if an equation mapper class
 cannot be foundCopyright © 2003–2016 The Apache Software Foundation. All rights reserved.