Bar-Part-Percent-Indicator

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

namespace WLUtility.Indicators
{
    /// <summary>
    ///     The part of the candle to calculate its percent.
    ///     This enum needs to be in the same scope level as the indicator so
    ///     that Wealth-Lab can parse (find) it for code generation.
    /// </summary>
    public enum CandlePart
    {
        Body = 0,
        BottomTail = 1,
        TopTail = 2
    }

    /// <summary>
    ///     Wealth-Lab indicator that calculates the percent of a candle's body, bottom tail, or top tail.
    /// </summary>
    public class CandlePartPercent : IndicatorBase
    {
        public CandlePartPercent()
        {
            // needed for WL8
        }

        public CandlePartPercent(BarHistory bars, CandlePart candlePart)
        {
            Parameters[0].Value = bars;
            Parameters[1].Value = candlePart;
            Populate();
        }

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

        public override string HelpDescription =>
            "Each candle's (bar's) body, bottom tail, or top tail expressed as a percent (0 to 100) of the candle's total size.";

        public override string PaneTag => "CandlePartPercent";
        public override PlotStyle DefaultPlotStyle => PlotStyle.Histogram;

        protected override void GenerateParameters()
        {
            AddParameter("Source", ParameterType.BarHistory, null);
            // default to body
            var part = AddParameter("Candle Part", ParameterType.StringChoice, "Body");
            part.Choices.Add("Body");
            part.Choices.Add("BottomTail");
            part.Choices.Add("TopTail");
            part.TypeName = "CandlePart";
        }

        public override void Populate()
        {
            var source = Parameters[0].AsBarHistory;
            // if part can't be parsed, we'll get an exception
            var part = (CandlePart) Enum.Parse(typeof(CandlePart), Parameters[1].AsString);
            DateTimes = source.DateTimes;

            // lets be speedy
            var closes = source.Close;
            var opens = source.Open;
            var highs = source.High;
            var lows = source.Low;
            var count = source.Count;

            // Although tedious, switch on the part and then use loops to speed things up. That way we don't
            // have to do switching within a loop.
            switch (part)
            {
                case CandlePart.Body:
                    for (var idx = 0; idx < count; idx++)
                    {
                        if (double.IsNaN(closes[idx]))
                        {
                            Values[idx] = double.NaN;
                            continue;
                        }

                        var barSize = highs[idx] - lows[idx];
                        Values[idx] = barSize > 0.0 ? Math.Abs(opens[idx] - closes[idx]) / barSize * 100.0 : 0.0;
                    }

                    break;
                case CandlePart.BottomTail:
                    for (var idx = 0; idx < count; idx++)
                    {
                        if (double.IsNaN(closes[idx]))
                        {
                            Values[idx] = double.NaN;
                            continue;
                        }

                        var barSize = highs[idx] - lows[idx];
                        Values[idx] = barSize > 0.0
                            ? (Math.Min(opens[idx], closes[idx]) - lows[idx]) / barSize * 100.0
                            : 0.0;
                    }

                    break;
                case CandlePart.TopTail:
                    for (var idx = 0; idx < count; idx++)
                    {
                        if (double.IsNaN(closes[idx]))
                        {
                            Values[idx] = double.NaN;
                            continue;
                        }

                        var barSize = highs[idx] - lows[idx];
                        Values[idx] = barSize > 0.0
                            ? (highs[idx] - Math.Max(opens[idx], closes[idx])) / barSize * 100.0
                            : 0.0;
                    }

                    break;
                // no default needed because we'll get an exception when parsing for the part, above
            }
        }

        public static CandlePartPercent Series(BarHistory bars, CandlePart candlePart)
        {
            var key = CacheKey("CandlePartPercent", (int) candlePart);
            if (bars.Cache.TryGetValue(key, out var obj))
            {
                return (CandlePartPercent) obj;
            }

            var result = new CandlePartPercent(bars, candlePart);
            bars.Cache[key] = result;
            return result;
        }
    }
}