How to implement indicator class N period standard deviation of range

Sure, I can help you with that. You can create a custom indicator that calculates the range (high minus low) for each period, and then use the STD helper method from the QCAlgorithm class to calculate the standard deviation of these ranges. Here's a basic example in Python:

class RangeStdDevAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.symbol = self.AddEquity("SPY", Resolution.Daily).Symbol
        self.range_indicator = self.Indicator(RangeIndicator(self.symbol, 14), self.symbol, Resolution.Daily)
        self.std = self.STD(self.range_indicator, 14)

    def OnData(self, slice: Slice):
        if self.std.IsReady:
            self.Debug(f"Standard deviation of range: {self.std.Current.Value}")

class RangeIndicator(PythonIndicator):
    def __init__(self, symbol, period):
        super().__init__(f"Range_{symbol}_{period}")
        self.symbol = symbol
        self.period = period
        self.window = RollingWindow[TradeBar](period)

    def Update(self, input: TradeBar):
        self.window.Add(input)
        if self.window.IsReady:
            ranges = [bar.High - bar.Low for bar in self.window]
            self.Current.Value = np.std(ranges)

    def IsReady(self):
        return self.window.IsReady

In this code, RangeIndicator is a custom indicator that calculates the range (high minus low) for each period. The STD method is then used to calculate the standard deviation of these ranges.

Please note that this is a basic example and you might need to adjust it according to your specific needs. For more information about creating custom indicators, you can refer to the QuantConnect documentation.

Is there an equivalent of the above in CSharp?

I think i figured out what i wanted…

#region imports
    using QuantConnect.Data.Market;
#endregion

namespace QuantConnect.Indicators
{

	public class Range : BarIndicator, IIndicatorWarmUpPeriodProvider
    {
        public override bool IsReady => Samples >= 1;
        public int WarmUpPeriod { get; }

         public Range(string name) : base(name)
        {
            WarmUpPeriod = 1;
        }

        public Range() : this($"Range()")
        {
            WarmUpPeriod = 1;
        }

        protected override decimal ComputeNextValue(IBaseDataBar input)
        {
            return input.High - input.Close;
        }
    }
    
    public class FrogBox : BarIndicator, IIndicatorWarmUpPeriodProvider
    {
        public IndicatorBase<IBaseDataBar> _range { get; }
        public IndicatorBase<IndicatorDataPoint> _std { get; }
        
        public override bool IsReady => _std.IsReady;
        public int WarmUpPeriod { get; }

         public FrogBox(int period)
            : this($"FrogBox({period})", period)
        {
        }

        public FrogBox(string name, int period)
            : base(name)
        {
            WarmUpPeriod = period;
            _range = new Range();
            _std = new StandardDeviation(name + "_std", period);
        }

        protected override decimal ComputeNextValue(IBaseDataBar input)
        {
            // compute the true range and then send it to our smoother
            _range.Update(input);
            _std.Update(input.Time, _range.Current.Value);

            return _std.Current.Value;
        }
    }
}

It looks like you've successfully created a custom indicator in C# that calculates the standard deviation of the range (high minus close) over a specified period. Your Range class calculates the range for each bar, and your FrogBox class uses this to calculate the standard deviation.

Here's the equivalent code in Python, in case you need it:

class Range(PythonIndicator):
    def __init__(self, name):
        super().__init__(name)
        self.IsReady = False

    def Update(self, input: IBaseDataBar):
        self.Current.Value = input.High - input.Close
        self.IsReady = True

class FrogBox(PythonIndicator):
    def __init__(self, name, period):
        super().__init__(name)
        self.period = period
        self.range = Range()
        self.std = StandardDeviation(name + "_std", period)

    def Update(self, input: IBaseDataBar):
        self.range.Update(input)
        self.std.Update(input.EndTime, self.range.Current.Value)
        self.Current.Value = self.std.Current.Value
        self.IsReady = self.std.IsReady

This Python code does the same thing as your C# code. The Range class calculates the range for each bar, and the FrogBox class uses this to calculate the standard deviation. The Update method in FrogBox updates the range and std indicators and sets the current value to the current value of the std indicator. The IsReady property is set to True when the std indicator is ready.

Please note that this is a basic example and you might need to adjust it according to your specific needs. For more information about creating custom indicators, you can refer to the QuantConnect documentation.