Getting a Algorithm to Execute at the Right Time

Hi Tate,

To check what the value of an indicator would be if we updated it with a new value, we can use the `ComputeNextValue` method. For example, if we create two EMAs and update them each minute.

Then when a new second resolution bar is passed to OnData, we can check what the current values of the EMAs would be at the current time.

See the attached backtest and logs for reference.

Best,
Derek Melchin

Hi Derek,

isn't that a solution only for the `ExponentialMovingAverage` and few other indicators for which `ComputeNextValue` does not change the state of the indicator?

ExponentialMovingAverage

protected override decimal ComputeNextValue(IndicatorDataPoint input)
         {
             // our first data point just return identity
             if (Samples == 1)
             {
                 return input.Value;
             }
             return input.Value * _k + Current.Value * (1 - _k);
         }

from my understanding looking at the implementation of e.g `SimpleMovingAverage` or `HullMovingAverage`, calling `ComputeNextValue` would actually update the indicator, not only return what it “would” be:

SimpleMovingAverage

protected override decimal ComputeNextValue(IReadOnlyWindow<IndicatorDataPoint> window, IndicatorDataPoint input)
         {
             RollingSum.Update(input.Time, input.Value);
             return RollingSum.Current.Value / window.Count;
         }

HullMovingAverage

protected override decimal ComputeNextValue(IndicatorDataPoint input)
         {
             _fastWma.Update(input);
             _slowWma.Update(input);
             if (_fastWma.IsReady && _slowWma.IsReady)
             {
                 _hullMa.Update(new IndicatorDataPoint(input.Time, 2 * _fastWma.Current.Value - _slowWma.Current.Value));
             }
             return _hullMa.Current.Value;
         }

By using the solution you suggested with `SimpleMovingAverage` or `HullMovingAverage` we would end up filling the indicator with minutely values instead of Daily values.

Is there a way to actually compute what the value would be of any indicator without risking to update its state? 

In order to achieve what Tate was thinking of I am currently on every iteration (Minute in my case) resetting my indicators and refilling them again with data from a rolling window (e.g of Close values of latest X days) plus the current minute close.
But of course this slows everything down.

Any idea on how to achieve this more efficiently?

It would be great if the Indicator class would expose a public method with no side effects for this purpose. What do you think?