public class _Alerts_MiRSI : Indicator
    {
        #region Variables
        private DataSeries                    avgUp;
        private DataSeries                    avgDown;
        private DataSeries                    down;
        private int                                period    = 14;
        private int                                smooth    = 3;
        private DataSeries                    up;
        #endregion

        /// <summary>
        /// This method is used to configure the indicator and is called once before any bar data is loaded.
        /// </summary>
        protected override void Initialize()
        {
            Add(new Plot(Color.Green, "MiRSI"));
            Add(new Plot(Color.Orange, "Avg"));

            Add(new Line(System.Drawing.Color.DarkViolet, 20, "Lower20"));
            Add(new Line(System.Drawing.Color.DarkViolet, 80, "Upper80"));
            Add(new Line(System.Drawing.Color.Red, 60, "Lower60"));
            Add(new Line(System.Drawing.Color.Red, 40, "Upper40"));
            Add(new Line(System.Drawing.Color.Blue, 50, "Upper50"));
            
            Add(new Plot(Color.FromKnownColor(KnownColor.Orange), PlotStyle.Line, "Alarma"));
            

            avgUp                = new DataSeries(this);
            avgDown                = new DataSeries(this);
            down                = new DataSeries(this);
            up                    = new DataSeries(this);

            PriceTypeSupported    = true;
        }

        /// <summary>
        /// Calculates the indicator value(s) at the current index.
        /// </summary>
        protected override void OnBarUpdate()
        {
            if (CurrentBar == 0)
            {
                down.Set(0);
                up.Set(0);
                return;
            }

            down.Set(Math.Max(Input[1] - Input[0], 0));
            up.Set(Math.Max(Input[0] - Input[1], 0));

            if ((CurrentBar + 1) < Period) 
            {
                if ((CurrentBar + 1) == (Period - 1))
                    Avg.Set(50);
                return;
            }

            if ((CurrentBar + 1) == Period) 
            {
                // First averages 
                avgDown.Set(SMA(down, Period)[0]);
                avgUp.Set(SMA(up, Period)[0]);
            }  
            else 
            {
                // Rest of averages are smoothed
                avgDown.Set((avgDown[1] * (Period - 1) + down[0]) / Period);
                avgUp.Set((avgUp[1] * (Period - 1) + up[0]) / Period);
            }

            double rs      = avgUp[0] / (avgDown[0] == 0 ? 1 : avgDown[0]);
            double rsi      = 100 - (100 / (1 + rs));
            double rsiAvg = (2.0 / (1 + Smooth)) * rsi + (1 - (2.0 / (1 + Smooth))) * Avg[1];

            Avg.Set(rsiAvg);
            Value.Set(rsi);
            
            Alarma.Set(rsi[1] < Upper40[1]&&rsi[0] > Upper40[0] ? 1 : 0);
        }

        #region Properties
        /// <summary>
        /// </summary>
        [Browsable(false)]
        [XmlIgnore()]
        public DataSeries Avg
        {
            get { return Values[1]; }
        }

        /// <summary>
        /// </summary>
        [Browsable(false)]
        [XmlIgnore()]
        public DataSeries Default
        {
            get { return Values[0]; }
        }
        
        /// <summary>
        /// </summary>
        [Description("Numbers of bars used for calculations")]
        [Category("Parameters")]
        public int Period
        {
            get { return period; }
            set { period = Math.Max(2, value); }
        }

        /// <summary>
        /// </summary>
        [Description("Number of bars for smoothing")]
        [Category("Parameters")]
        public int Smooth
        {
            get { return smooth; }
            set { smooth = Math.Max(1, value); }
        }
        
        
            
            
        
        
        #endregion
    }
}

#region NinjaScript generated code. Neither change nor remove.
// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
    public partial class Indicator : IndicatorBase
    {
        private _Alerts_MiRSI[] cache_Alerts_MiRSI = null;

        private static _Alerts_MiRSI check_Alerts_MiRSI = new _Alerts_MiRSI();

        /// <summary>
        /// The MiRSI (Relative Strength Index) is a price-following oscillator that ranges between 0 and 100.
        /// </summary>
        /// <returns></returns>
        public _Alerts_MiRSI _Alerts_MiRSI(int period, int smooth)
        {
            return _Alerts_MiRSI(Input, period, smooth);
        }

        /// <summary>
        /// The MiRSI (Relative Strength Index) is a price-following oscillator that ranges between 0 and 100.
        /// </summary>
        /// <returns></returns>
        public _Alerts_MiRSI _Alerts_MiRSI(Data.IDataSeries input, int period, int smooth)
        {
            check_Alerts_MiRSI.Period = period;
            period = check_Alerts_MiRSI.Period;
            check_Alerts_MiRSI.Smooth = smooth;
            smooth = check_Alerts_MiRSI.Smooth;

            if (cache_Alerts_MiRSI != null)
                for (int idx = 0; idx < cache_Alerts_MiRSI.Length; idx++)
                    if (cache_Alerts_MiRSI[idx].Period == period && cache_Alerts_MiRSI[idx].Smooth == smooth && cache_Alerts_MiRSI[idx].EqualsInput(input))
                        return cache_Alerts_MiRSI[idx];

            _Alerts_MiRSI indicator = new _Alerts_MiRSI();
            indicator.BarsRequired = BarsRequired;
            indicator.CalculateOnBarClose = CalculateOnBarClose;
            indicator.Input = input;
            indicator.Period = period;
            indicator.Smooth = smooth;
            indicator.SetUp();

            _Alerts_MiRSI[] tmp = new _Alerts_MiRSI[cache_Alerts_MiRSI == null ? 1 : cache_Alerts_MiRSI.Length + 1];
            if (cache_Alerts_MiRSI != null)
                cache_Alerts_MiRSI.CopyTo(tmp, 0);
            tmp[tmp.Length - 1] = indicator;
            cache_Alerts_MiRSI = tmp;
            Indicators.Add(indicator);

            return indicator;
        }

    }
}

// This namespace holds all market analyzer column definitions and is required. Do not change it.
namespace NinjaTrader.MarketAnalyzer
{
    public partial class Column : ColumnBase
    {
        /// <summary>
        /// The MiRSI (Relative Strength Index) is a price-following oscillator that ranges between 0 and 100.
        /// </summary>
        /// <returns></returns>
        [Gui.Design.WizardCondition("Indicator")]
        public Indicator._Alerts_MiRSI _Alerts_MiRSI(int period, int smooth)
        {
            return _indicator._Alerts_MiRSI(Input, period, smooth);
        }

        /// <summary>
        /// The MiRSI (Relative Strength Index) is a price-following oscillator that ranges between 0 and 100.
        /// </summary>
        /// <returns></returns>
        public Indicator._Alerts_MiRSI _Alerts_MiRSI(Data.IDataSeries input, int period, int smooth)
        {
            return _indicator._Alerts_MiRSI(input, period, smooth);
        }

    }
}

// This namespace holds all strategies and is required. Do not change it.
namespace NinjaTrader.Strategy
{
    public partial class Strategy : StrategyBase
    {
        /// <summary>
        /// The MiRSI (Relative Strength Index) is a price-following oscillator that ranges between 0 and 100.
        /// </summary>
        /// <returns></returns>
        [Gui.Design.WizardCondition("Indicator")]
        public Indicator._Alerts_MiRSI _Alerts_MiRSI(int period, int smooth)
        {
            return _indicator._Alerts_MiRSI(Input, period, smooth);
        }

        /// <summary>
        /// The MiRSI (Relative Strength Index) is a price-following oscillator that ranges between 0 and 100.
        /// </summary>
        /// <returns></returns>
        public Indicator._Alerts_MiRSI _Alerts_MiRSI(Data.IDataSeries input, int period, int smooth)
        {
            if (InInitialize && input == null)
                throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method");

            return _indicator._Alerts_MiRSI(input, period, smooth);
        }

    }
}
#endregion