## org.apache.commons.math.ode.jacobians
Interface StepHandlerWithJacobians

    public interface StepHandlerWithJacobians

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
Version:
  $Revision: 920131 $ $Date: 2010-03-07 17:19:18 -0500 (Sun, 07 Mar 2010) $
See Also:
  `FirstOrderIntegratorWithJacobians`, `StepInterpolatorWithJacobians`

Method Summary
`void` `handleStep(StepInterpolatorWithJacobians interpolator, boolean isLast)` Handle the last accepted step
`boolean` `requiresDenseOutput()` Determines whether this handler needs dense output.
`void` `reset()` Reset the step handler.

Method Detail

### requiresDenseOutput

    boolean requiresDenseOutput()

  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()

  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

  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

Copyright (c) 2003-2011 Apache Software Foundation