Relative-Volume-Indicator

CODE:
using System;
using System.Collections.Generic;
using WealthLab.Core;
using WealthLab.Data;
using WealthLab.Indicators;
using WealthLab.PowerPack;

namespace WLUtility.Indicators
{
    /// <summary>
    ///     Wealth-Lab 8 indicator that calculates the cumulative intra-day volume divided by the average volume of
    ///     the same periods of the prior N days. It loads data via GetHistory so that results are readily available
    ///     within the strategy's data range. Hence, you don't need to use a "wide" intra-day data range in the strategy
    ///     just to get the data needed for the calculations.
    ///     This indicator is useful for identifying unusual volume during certain times of day.
    ///     This indicator requires the Wealth-Lab PowerPack extension.
    ///     Works for N minute data scale frequency only.
    ///     Should only be used for scales for which one day of time divided by the scale's time span
    ///     is an integer - e.g. 1 minute, 2 minutes, 3 minutes, 5 minutes, 10 minutes, 15 minutes, 30 minutes,
    ///     60 minutes and any others.
    /// </summary>
    public class RelativeVolume : IndicatorBase
    {
        public RelativeVolume()
        {
            // needed for WL8
        }

        public RelativeVolume(BarHistory barHistory, int period = 20)
        {
            Parameters[0].Value = barHistory;
            Parameters[1].Value = period;
            Populate();
        }

        public override PlotStyle DefaultPlotStyle => PlotStyle.Line;
        public override WLColor DefaultColor => WLColor.Green;
        public override bool IsCalculationLengthy => false;
        private BarHistory Source => Parameters[0].AsBarHistory;
        private int Period => Parameters[1].AsInt;

        public override string Name => "RelativeVolume";
        public override string Abbreviation => "RelativeVolume";

        public override string HelpDescription =>
            "Cumulative intra-day volume divided by the average volume of the same periods of the prior N days";

        public override string PaneTag => "RelativeVolume";

        protected override void GenerateParameters()
        {
            AddParameter("Source", ParameterType.BarHistory, null);
            AddParameter("Period", ParameterType.Int32, 20);
        }

        public override void Populate()
        {
            // make things speedier
            var source = Source;
            FirstValidIndex = 0;

            // if the source scale's frequency must be minute
            if (source.Scale.Frequency != Frequency.Minute)
            {
                // not supported so not much to do here
                for (var i = 0; i < source.Count; i++)
                {
                    Add(double.NaN, source.DateTimes[i]);
                }

                return;
            }

            var period = Period;

            // Use GetHistory because the settings for a back test or live trading could be quite different from the 
            // required days needed for the calculations. Don't short-change the results by using the source data only.
            // The user may want to go back a lot of days.
            var fromDate = source.SubtractTradingDays(0, period).Date;
            var cb = new DataRequestOptions
            {
                FilterPrePost = false,
                OfflineModeOverride = true
            };

            // fetch the bar history
            var history = WLHost.Instance.GetHistory(source.Symbol, source.Scale, fromDate,
                source.DateTimes[source.Count - 1], int.MaxValue, cb);

            // We need to use intraday volume data. Wealth-Lab PowerPack is required because it contains
            // the DailyValueAsOf indicator.
            var intraDayVolumeAsOf = new DailyValueAsOf(history, PriceComponent.Volume);

            // Build a volume/datetime list that is not sparse of the date/times - it will
            // have a date/time with volume for every period of time in the scale from the start
            // of the history to the end of the history. This makes it very easy to traverse
            // by time units.
            var nonSparse = new List<(double volume, DateTime dateTime)>(intraDayVolumeAsOf.Count * 2);

            // how long is the scale in time?
            // this implementation only works for scales that are a multiple of minutes
            var scaleTimeSpan = TimeSpan.FromMinutes(source.Scale.Interval);

            // how many units of scale time are in a day?
            var scaleTimeSpanUnitsPerDay = (int) (new TimeSpan(24, 0, 0) / scaleTimeSpan);

            // build the nonSparse list
            for (var intraDayVolumeIdx = 0; intraDayVolumeIdx < intraDayVolumeAsOf.Count; intraDayVolumeIdx++)
            {
                var volume = intraDayVolumeAsOf[intraDayVolumeIdx];
                var date = intraDayVolumeAsOf.DateTimes[intraDayVolumeIdx];
                var saveDate = date;
                // store the intra-day volume for the current datetime
                nonSparse.Add((volume, date));

                // move to the next datetime
                date += scaleTimeSpan;

                // if we are at the end of the list then we are done
                // otherwise, if the next datetime is not the next datetime in the intraDayVolumeAsOf list
                if (intraDayVolumeIdx >= intraDayVolumeAsOf.Count - 1 ||
                    date >= intraDayVolumeAsOf.DateTimes[intraDayVolumeIdx + 1])
                {
                    continue;
                }

                // need to stop at the next datetime
                var nextDate = intraDayVolumeAsOf.DateTimes[intraDayVolumeIdx + 1];

                // keep adding the same volume until the next date in intraDayVolumeAsOf
                while (date < nextDate)
                {
                    if (date.Date != saveDate.Date)
                    {
                        // changed days - reset the volume
                        volume = 0.0;
                    }

                    // don't add intra-day volume for non-trading days
                    if (source.Market.IsTradingDay(date))
                    {
                        nonSparse.Add((volume, date));
                    }
                    date += scaleTimeSpan;
                }
            }

            var nonSparseIdx = 0;

            // for each source bar...
            for (var sourceIdx = 0; sourceIdx < source.Count; sourceIdx++)
            {
                var srcDate = source.DateTimes[sourceIdx];
                while (nonSparse[nonSparseIdx].dateTime < srcDate && nonSparseIdx < nonSparse.Count)
                {
                    nonSparseIdx++;
                }

                if (nonSparseIdx >= nonSparse.Count)
                {
                    break;
                }

                // sum the volume for the period by walking back in the nonSparse time series
                // nonSparseIdx is the index of the volume (within nonSparse) that corresponds to the current source bar
                var sum = 0.0;
                var j = nonSparseIdx - scaleTimeSpanUnitsPerDay;
                var count = 0;
                while (count < period && j >= 0)
                {
                    sum += nonSparse[j].volume;
                    j -= scaleTimeSpanUnitsPerDay;
                    count++;
                }

                var avg = count == 0 ? 0 : sum / count;

                Add(avg == 0 ? 0 : nonSparse[nonSparseIdx].volume / avg, srcDate);
                // for testing
                //Add(sum, srcDate);
            }
        }

        public static RelativeVolume Series(BarHistory barHistory, int period = 20)
        {
            var key = CacheKey("RelativeVolume", period);
            if (barHistory.Cache.TryGetValue(key, out var rv))
            {
                return (RelativeVolume) rv;
            }

            var result = new RelativeVolume(barHistory, period);
            barHistory.Cache[key] = result;
            return result;
        }
    }
}