/**
 * <p>
 * Interface for numerical integrator.
 * This determines continuous time evolution of control law.
 * Should be made so that some generic java numerical integration
 * routine from some other software package can be easily wrapped
 * by a class conforming to this interface.
 * </p>
 * @author     Michael Schuresko
 * @version    %I%, %G%
 * @since      1.0
*/

public interface INumericalIntegrator
{
    /**
     * Assumes that time does not step over an agent 
     * state change event.
     * Other classes should handle this constraint.
     * @param lfTimeStop integrate until this time.
     * @param lfTCurr current (start) time
     * @param arrLfState state vector (initially initial state,
     * overwritten with final state)
     * @param arrLfDerivScratch state derivative vector scratch space 
     * (should be same dimensionality as state vector)
     * @param agent agent mapping (currently only support for homogenous swarms
     * )
     * @param arrStates discrete state and control func of each agent (assumed
     * not to change over integration)
     * @param arrSensors array of sensor interfaces.
     * @param env environment
     * @param drawCallback callback for drawing routines (can be null)
     * @param haltCallback callback to check if we should halt (can be null)
     * @return actual absolute (simulation) 
     * time at which we stopped integration, whether due to an
     * interruption, or concluding the computation (lfTimeStop).
     */
    public double integrateUntil(double lfTimeStop,
				 double lfTCurr,
				 double [] arrLfState,
				 double [] arrLfDerivScratch,
				 IAgent agent,
				 StateBundle [] arrStates,
				 ISensor [] arrSensors,
				 IEnvironment env,
				 ISimUICallback drawCallback,
				 ISimUICallback haltCallback);
}