Package org.apache.commons.math.ode.jacobians

Interface StepHandlerWithJacobians

  • @Deprecated
public interface StepHandlerWithJacobians
    Deprecated.
    as of 2.2 the complete package is deprecated, it will be replaced in 3.0 by a completely rewritten implementation
    This interface represents a handler that should be called after each successful step.

    The ODE integrators compute the evolution of the state vector at some grid points that depend on their own internal algorithm. Once they have found a new grid point (possibly after having computed several evaluation of the derivative at intermediate points), they provide it to objects implementing this interface. These objects typically either ignore the intermediate steps and wait for the last one, store the points in an ephemeris, or forward them to specialized processing or output methods.

    Note that is is possible to register a classical step handler in the low level integrator used to build a FirstOrderIntegratorWithJacobians rather than implementing this class. The step handlers registered at low level will see the big compound state whether the step handlers defined by this interface see the original state, and its jacobians in separate arrays.

    The compound state is guaranteed to contain the original state in the first elements, followed by the jacobian with respect to initial state (in row order), followed by the jacobian with respect to parameters (in row order). If for example the original state dimension is 6 and there are 3 parameters, the compound state will be a 60 elements array. The first 6 elements will be the original state, the next 36 elements will be the jacobian with respect to initial state, and the remaining 18 elements will be the jacobian with respect to parameters.

    Dealing with low level step handlers is cumbersome if one really needs the jacobians in these methods, but it also prevents many data being copied back and forth between state and jacobians on one side and compound state on the other side. So for performance reasons, it is recommended to use this interface only if jacobians are really needed and to use lower level handlers if only state is needed.

    Since:
    2.1
    See Also:
    FirstOrderIntegratorWithJacobians, StepInterpolatorWithJacobians

    • Method Detail

      • requiresDenseOutput

        boolean requiresDenseOutput()
        Deprecated.
        Determines whether this handler needs dense output.

        This method allows the integrator to avoid performing extra computation if the handler does not need dense output.

        Returns:
        true if the handler needs dense output

      • reset

        void reset()
        Deprecated.
        Reset the step handler. Initialize the internal data as required before the first step is handled.

      • handleStep

        void handleStep​(StepInterpolatorWithJacobians interpolator,
                boolean isLast)
         throws DerivativeException
        Deprecated.
        Handle the last accepted step
        Parameters:
        interpolator - interpolator for the last accepted step. For efficiency purposes, the various integrators reuse the same object on each call, so if the instance wants to keep it across all calls (for example to provide at the end of the integration a continuous model valid throughout the integration range, as the ContinuousOutputModel class does), it should build a local copy using the clone method of the interpolator and store this copy. Keeping only a reference to the interpolator and reusing it will result in unpredictable behavior (potentially crashing the application).
        isLast - true if the step is the last one
        Throws:
        DerivativeException - this exception is propagated to the caller if the underlying user function triggers one