Anchored-VWAP-indicator

I improved the indicator by allowing a TimeSeries to be specified for the price component (the P) in VWAP. This way you can use any TimeSeries for the price instead of the previously hardcoded AveragePriceHLC. Of course, the TimeSeries should ideally be derived from and synchronized with the source bars.

The TimeSeries defaults to AveragePriceHLC of the bars. This is a breaking change to the code of Post #8 above because of the TimeSeries parameter was added...

CODE:
using System;
using WealthLab.Core;
using WealthLab.Indicators;

namespace WLUtility.Indicators
{
    /// <summary>
    ///     Anchored VWAP indicator that allows anchoring VWAP by date/time or by an n-bar sliding window.
    ///     The price (the P in VWAP) is specified by a TimeSeries. This defaults to AveragePriceHLC.
    /// </summary>
    public class AnchoredVwap : IndicatorBase
    {
        private const int ParamIndexSource = 0;
        private const int ParamIndexTimeSeries = 1;
        private const int ParamIndexAnchorDate = 2;
        private const int ParamIndexUseLength = 3;
        private const int ParamIndexLength = 4;

        public AnchoredVwap()
        {
            // for WL 8 - do not remove
        }

        public AnchoredVwap(BarHistory source, TimeSeries timeSeries, DateTime anchorDate, bool useLength, int length)
        {
            Parameters[ParamIndexSource].Value = source;
            Parameters[ParamIndexTimeSeries].Value = timeSeries;
            Parameters[ParamIndexAnchorDate].Value = anchorDate;
            Parameters[ParamIndexUseLength].Value = useLength;
            Parameters[ParamIndexLength].Value = length;
            Populate();
        }

        private BarHistory Source => Parameters[ParamIndexSource].AsBarHistory;
        private TimeSeries TimeSeries => Parameters[ParamIndexTimeSeries].AsTimeSeries;
        private DateTime AnchorDateTime => Parameters[ParamIndexAnchorDate].AsDate;
        private bool UseLength => Parameters[ParamIndexUseLength].AsBoolean;
        private int Length => Parameters[ParamIndexLength].AsInt;

        public override string Name => "Anchored VWAP";
        public override string Abbreviation => "Anchored VWAP";
        public override string HelpDescription => "Anchored VWAP by date or bar count";
        public override string PaneTag => "Price";
        public override WLColor DefaultColor { get; } = WLColor.Purple;

        public override void Populate()
        {
            double cumulativePriceVolume = 0, cumulativeVolume = 0;

            // be speedy
            var source = Source;
            var ts = TimeSeries;
            var volume = source.Volume;
            var tsFirstValidIndex = ts.FirstValidIndex;

            DateTimes = source.DateTimes;

            if (UseLength)
            {
                // sliding window...
                var length = Length;
                if (length < 1)
                {
                    // For an invalid length don't throw an exception because it will cause a problem when using building blocks
                    // as of WL 8 Build 54.
                    // When running a strategy or dragged to a chart, all values will be NaN.
                    // So, dont' use an invalid length.
                    return;
                }

                var startIdx = tsFirstValidIndex + length - 1;

                // accumulate volume and price * volume to use for the first result value that can be generated
                for (var idx = tsFirstValidIndex; idx < startIdx && idx < ts.Count; idx++)
                {
                    cumulativePriceVolume += ts[idx] * volume[idx];
                    cumulativeVolume += volume[idx];
                }

                var removeIdx = tsFirstValidIndex;
                for (var idx = startIdx; idx < ts.Count; idx++)
                {
                    cumulativePriceVolume += ts[idx] * volume[idx];
                    cumulativeVolume += volume[idx];
                    Values[idx] = cumulativeVolume == 0 ? double.NaN : cumulativePriceVolume / cumulativeVolume;

                    // remove oldest from accumulators
                    cumulativePriceVolume -= ts[removeIdx] * volume[removeIdx];
                    cumulativeVolume -= volume[removeIdx];
                    removeIdx++;
                }

                // if no valid values, just set to one past end of the time series
                FirstValidIndex = Math.Min(startIdx, ts.Count);
            }
            else
            {
                // fixed date/time...
                var startIdx = source.IndexOf(AnchorDateTime);
                if (startIdx > -1)
                {
                    // if starting in an invalid index into the time series then
                    // move up to the first valid index
                    if (startIdx < tsFirstValidIndex)
                    {
                        startIdx = tsFirstValidIndex;
                    }

                    for (var idx = startIdx; idx < source.Count; idx++)
                    {
                        cumulativePriceVolume += ts[idx] * volume[idx];
                        cumulativeVolume += volume[idx];
                        Values[idx] = cumulativeVolume == 0 ? double.NaN : cumulativePriceVolume / cumulativeVolume;
                    }

                    FirstValidIndex = startIdx;
                }
                else
                {
                    // no valid values, just set to one past end of the time series
                    FirstValidIndex = ts.Count;
                }
            }
        }

        public static AnchoredVwap Series(BarHistory source, TimeSeries timeSeries, DateTime anchorDate, bool useLength,
            int length)
        {
            var key = CacheKey("AnchoredVWAP", timeSeries, anchorDate, useLength, length);
            if (source.Cache.TryGetValue(key, out var vwap))
            {
                return (AnchoredVwap) vwap;
            }

            var result = new AnchoredVwap(source, timeSeries, anchorDate, useLength, length);
            source.Cache[key] = result;
            return result;
        }

        protected override void GenerateParameters()
        {
            AddParameter("Source", ParameterType.BarHistory, null);
            AddParameter("Price", ParameterType.TimeSeries, PriceComponent.AveragePriceHLC);
            AddParameter("Anchor Date", ParameterType.Date, DateTime.Now.Date);
            AddParameter("Use length instead of anchor date?", ParameterType.Boolean, false);
            AddParameter("Length", ParameterType.Int32, 20);
        }
    }
}