for (int bar = firstBar; bar < Bars; bar++)
      adRange[bar] = ((constante*(rMAFast[bar] - rMASlow[bar])*(fastATR2[bar]) + constante2)/(rMASlow[bar])/slowATR2[bar]);

            for (int iBar = nSlow + nSignal - 1; iBar < Bars; iBar++)
                adHistogram[iBar] = adRange2[iBar];

using System;
using System.Drawing;

namespace Forex_Strategy_Builder
{
    /// <summary>
    /// MACD Histogram Indicator
    /// </summary>
    public class MACD_Histogram : Indicator
    {
        /// <summary>
        /// <summary>
        /// Sets the default indicator parameters for the designated slot type
        /// </summary>
        public MACD_Histogram(SlotTypes slotType)
        {
            // General properties
            IndicatorName = "Synerge Range";
            PossibleSlots = SlotTypes.OpenFilter | SlotTypes.CloseFilter;
            SeparatedChart = true;
            CustomIndicator = true;    

            // Setting up the indicator parameters
            IndParam = new IndicatorParam();
            IndParam.IndicatorName = IndicatorName;
            IndParam.SlotType = slotType;

            // The ComboBox parameters
            IndParam.ListParam[0].Caption = "Logic";
            IndParam.ListParam[0].ItemList = new string[]
            {
                "The Range rises",
                "The Range falls",
                "The Range is higher than the Level line",
                "The Range is lower than the Level line",
                "The Range crosses the Level line upward",
                "The Range crosses the Level line downward",
                "The Range changes its direction upward",
                "The Range changes its direction downward"
            };
            IndParam.ListParam[0].Index = 0;
            IndParam.ListParam[0].Text = IndParam.ListParam[0].ItemList[IndParam.ListParam[0].Index];
            IndParam.ListParam[0].Enabled = true;
            IndParam.ListParam[0].ToolTip = "Logic of application of the indicator.";

            IndParam.ListParam[1].Caption = "Smoothing method";
            IndParam.ListParam[1].ItemList = Enum.GetNames(typeof(MAMethod));
            IndParam.ListParam[1].Index = (int)MAMethod.Exponential;
            IndParam.ListParam[1].Text = IndParam.ListParam[1].ItemList[IndParam.ListParam[1].Index];
            IndParam.ListParam[1].Enabled = true;
            IndParam.ListParam[1].ToolTip = "The smoothing method of Moving Averages.";

            IndParam.ListParam[2].Caption = "Base price";
            IndParam.ListParam[2].ItemList = Enum.GetNames(typeof(BasePrice));
            IndParam.ListParam[2].Index = (int)BasePrice.Close;
            IndParam.ListParam[2].Text = IndParam.ListParam[2].ItemList[IndParam.ListParam[2].Index];
            IndParam.ListParam[2].Enabled = true;
            IndParam.ListParam[2].ToolTip = "The price the Moving Averages are based on.";

            IndParam.ListParam[3].Caption = "Signal line method";
            IndParam.ListParam[3].ItemList = Enum.GetNames(typeof(MAMethod));
            IndParam.ListParam[3].Index = (int)MAMethod.Simple;
            IndParam.ListParam[3].Text = IndParam.ListParam[3].ItemList[IndParam.ListParam[3].Index];
            IndParam.ListParam[3].Enabled = true;
            IndParam.ListParam[3].ToolTip = "The smoothing method of the signal line.";

            // The NumericUpDown parameters
            IndParam.NumParam[0].Caption = "Slow MA period";
            IndParam.NumParam[0].Value = 34;
            IndParam.NumParam[0].Min = 1;
            IndParam.NumParam[0].Max = 200;
            IndParam.NumParam[0].Enabled = true;
            IndParam.NumParam[0].ToolTip = "The period of Slow MA.";

            IndParam.NumParam[1].Caption = "Fast MA period";
            IndParam.NumParam[1].Value = 3;
            IndParam.NumParam[1].Min = 1;
            IndParam.NumParam[1].Max = 200;
            IndParam.NumParam[1].Enabled = true;
            IndParam.NumParam[1].ToolTip = "The period of Fast MA.";

            IndParam.NumParam[2].Caption = "Signal line period";
            IndParam.NumParam[2].Value = 1;
            IndParam.NumParam[2].Min = 1;
            IndParam.NumParam[2].Max = 200;
            IndParam.NumParam[2].Enabled = true;
            IndParam.NumParam[2].ToolTip = "The period of Signal line.";

            IndParam.NumParam[3].Caption = "Level";
            IndParam.NumParam[3].Value = 0.0000;
            IndParam.NumParam[3].Min = -2;
            IndParam.NumParam[3].Max = 2;
            IndParam.NumParam[3].Point = 4;
            IndParam.NumParam[3].Enabled = true;
            IndParam.NumParam[3].ToolTip = "A critical level (for the appropriate logic).";

            // The CheckBox parameters
            IndParam.CheckParam[0].Caption = "Use previous bar value";
            IndParam.CheckParam[0].Checked = PrepareUsePrevBarValueCheckBox(slotType);
            IndParam.CheckParam[0].Enabled = true;
            IndParam.CheckParam[0].ToolTip = "Use the indicator value from the previous bar.";

            return;
        }

        /// <summary>
        /// Calculates the indicator's components
        /// </summary>
        public override void Calculate(SlotTypes slotType)
        {
            // Reading the parameters
            MAMethod maMethod = (MAMethod)IndParam.ListParam[1].Index;
            MAMethod slMethod = (MAMethod)IndParam.ListParam[3].Index;
            BasePrice basePrice = (BasePrice)IndParam.ListParam[2].Index;
            int nSlow = (int)IndParam.NumParam[0].Value;
            int nFast = (int)IndParam.NumParam[1].Value;
            int nSignal = (int)IndParam.NumParam[2].Value;
            double dLevel = IndParam.NumParam[3].Value;
            int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;

            // Calculation
            int iFirstBar = nSlow + nFast + 2;

            double constante = 100.0;
            double constante2 = 0.00001;
            double[] adRange = new double[Bars];
            double[] adRange2 = new double[Bars];

            /*ld_8 = 100.0 * (iMA(NULL, 0, 3, 0, MODE_LWMA, PRICE_CLOSE, li_36) - iMA(NULL, 0, 34, 0, MODE_LWMA, PRICE_CLOSE, li_36)) * iATR(NULL, 0, 3, li_36) + 0.00001;
            ld_16 = ld_8 / iMA(NULL, 0, 34, 0, MODE_LWMA, PRICE_CLOSE, li_36) / iATR(NULL, 0, 34, li_36);
            ld_24 = (MathExp(2.0 * ld_16) - 1.0) / (MathExp(2.0 * ld_16) + 1.0);*/

            double[] fastATR = new double[Bars];
           for (int bar = 1; bar < Bars; bar++)
             fastATR[bar] = (double)Math.Max(High[bar], Close[bar - 1]) - (double)Math.Min(Low[bar], Close[bar - 1]);
          
             double[] fastATR2 = MovingAverage(nFast, 0, slMethod, fastATR);
            
            double[] slowATR = new double[Bars];
            for (int bar = 1; bar < Bars; bar++)
               slowATR[bar] = (double)Math.Max(High[bar], Close[bar - 1]) - (double)Math.Min(Low[bar], Close[bar - 1]);
                      
               double[] slowATR2 = MovingAverage(nSlow, 0, slMethod, slowATR);
               
               double [] rMASlow = MovingAverage(nSlow, 0, maMethod, Price(basePrice));
               double [] rMAFast = MovingAverage(nFast, 0, maMethod, Price(basePrice));

               for (int ibar = iFirstBar; ibar < Bars; ibar++)
                   adRange[ibar] = ((constante * (rMAFast[ibar] - rMASlow[ibar]) * (fastATR2[ibar]) + constante2) / (rMASlow[ibar]) / slowATR2[ibar]);
              
               for (int ibar = iFirstBar; ibar < Bars; ibar++)
                   adRange2[ibar] = (Math.Exp((2.0 * adRange[ibar]) - 1.0))/(Math.Exp((2.0 * adRange[ibar]) + 1.0));


         /*   double[] ATR = new double[Bars];
            double[] ATR2 = new double[Bars];
            double[] Range = new double[Bars];
            double[] Factor = new double[Bars];
            double[] rMASlow = new double[Bars];
            double[] rMAFast = new double[Bars];
            double[] Factor1 = new double[Bars];
            double[] Factor2 = new double[Bars];
            double[] adRange = new double[Bars];
            double[] adRange2 = new double[Bars];
            double constante = 100.0;
            double constante2 = 0.00001;


            for (int iBar = 1; iBar < Bars; iBar++)
            {
                ATR[iBar] = ((double)Math.Max(High[iBar], Close[iBar - 1]) - (double)Math.Min(Low[iBar], Close[iBar - 1]));
                ATR = MovingAverage(nFast, 0, maMethod, ATR);
                for (int iBary = 1; iBary < Bars; iBary++)
                {
                    ATR2[iBary] = ((double)Math.Max(High[iBary], Close[iBary - 1]) - (double)Math.Min(Low[iBary], Close[iBary - 1]));
                    ATR2 = MovingAverage(nSlow, 0, maMethod, ATR2);





                    rMASlow = MovingAverage(nSlow, 0, maMethod, Price(basePrice));
                    rMAFast = MovingAverage(nFast, 0, maMethod, Price(basePrice));

                    //  for (int iBar = 1; iBar < Bars; iBar++)
                    //     Range[iBar] = (100.0 * (rMAFast[iBar] - rMASlow[iBar]) * (ATR[iBar]) + 0.00001);
                    // for (int iBar = 1; iBar < Bars; iBar++)
                    //    Factor[iBar] = Range[iBar] / rMAFast[iBar] / ATR2[iBar];
                    for (int iBaru = iFirstBar; iBaru < Bars; iBaru++)
                        Range[iBaru] = constante * (rMAFast[iBaru] - rMASlow[iBaru]) * ATR[iBaru] + constante2;
                    for (int iBari = iFirstBar; iBari < Bars; iBari++)
                        Factor[iBari] = (Range[iBari] / rMAFast[iBari] / ATR2[iBari]);

                    for (int iBaro = iFirstBar; iBaro < Bars; iBaro++)
                        Factor1[iBaro] = Math.Exp(((2.0) * Factor[iBaro]) - 1.0);
                    for (int iBarp = iFirstBar; iBarp < Bars; iBarp++)
                        Factor2[iBarp] = Math.Exp(((2.0) * Factor[iBarp]) + 1.0);
                    for (int iBarq = iFirstBar; iBarq < Bars; iBarq++)
                        adRange2[iBarq] = Factor1[iBarq] / Factor2[iBarq];

                    for (int iBarw = iFirstBar; iBarw < Bars; iBarw++)
                        adRange[iBarw] = adRange2[iBarw];
                }
            }*/

               double[] maSignalLine = MovingAverage(nSignal, 0, slMethod, adRange2);

           
            double[] adHistogram = new double[Bars];
            for (int iBar = nSlow + nSignal - 1; iBar < Bars; iBar++)
                adHistogram[iBar] = adRange2[iBar];

            // Saving the components
            Component = new IndicatorComp[5];

            Component[0] = new IndicatorComp();
            Component[0].CompName = "Histogram";
            Component[0].DataType = IndComponentType.IndicatorValue;
            Component[0].ChartType = IndChartType.Histogram;
            Component[0].FirstBar = iFirstBar;
            Component[0].Value = adRange2;

            Component[1] = new IndicatorComp();
            Component[1].CompName = "Signal line";
            Component[1].DataType = IndComponentType.IndicatorValue;
            Component[1].ChartType = IndChartType.Line;
            Component[1].ChartColor = Color.Gold;
            Component[1].FirstBar = iFirstBar;
            Component[1].Value = maSignalLine;

            Component[2] = new IndicatorComp();
            Component[2].CompName = "Synergy Range line";
            Component[2].DataType = IndComponentType.IndicatorValue;
            Component[2].ChartType = IndChartType.Line;
            Component[2].ChartColor = Color.Blue;
            Component[2].FirstBar = iFirstBar;
            Component[2].Value = adRange2;

            Component[3] = new IndicatorComp();
            Component[3].ChartType = IndChartType.NoChart;
            Component[3].FirstBar = iFirstBar;
            Component[3].Value = new double[Bars];

            Component[4] = new IndicatorComp();
            Component[4].ChartType = IndChartType.NoChart;
            Component[4].FirstBar = iFirstBar;
            Component[4].Value = new double[Bars];

            // Sets the Component's type
            if (slotType == SlotTypes.OpenFilter)
            {
                Component[3].DataType = IndComponentType.AllowOpenLong;
                Component[3].CompName = "Is long entry allowed";
                Component[4].DataType = IndComponentType.AllowOpenShort;
                Component[4].CompName = "Is short entry allowed";
            }
            else if (slotType == SlotTypes.CloseFilter)
            {
                Component[3].DataType = IndComponentType.ForceCloseLong;
                Component[3].CompName = "Close out long position";
                Component[4].DataType = IndComponentType.ForceCloseShort;
                Component[4].CompName = "Close out short position";
            }

            // Calculation of the logic
            IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;

            switch (IndParam.ListParam[0].Text)
            {
                case "The Range histogram rises":
                    indLogic = IndicatorLogic.The_indicator_rises;
                    break;

                case "The Range histogram falls":
                    indLogic = IndicatorLogic.The_indicator_falls;
                    break;

                case "The Range histogram is higher than the Level line":
                    indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
                    SpecialValues = new double[2] { dLevel, -dLevel };
                    break;

                case "The Range histogram is lower than the Level line":
                    indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
                    SpecialValues = new double[2] { dLevel, -dLevel };
                    break;

                case "The Range histogram crosses the Level line upward":
                    indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
                    SpecialValues = new double[2] { dLevel, -dLevel};
                    break;

                case "The Range histogram crosses the Level line downward":
                    indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
                    SpecialValues = new double[2] { dLevel, -dLevel };
                    break;

                case "The Range histogram changes its direction upward":
                    indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
                    break;

                case "The Range histogram changes its direction downward":
                    indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
                    break;

                default:
                    break;
            }

            OscillatorLogic(iFirstBar, iPrvs, adRange2, dLevel, -dLevel, ref Component[3], ref Component[4], indLogic);

            return;
        }

        /// <summary>
        /// Sets the indicator logic description
        /// </summary>
        public override void SetDescription(SlotTypes slotType)
        {
            string sLevelLong = (IndParam.NumParam[3].Value == 0 ? "0" : IndParam.NumParam[3].ValueToString);
            string sLevelShort = (IndParam.NumParam[3].Value == 0 ? "0" : "-" + IndParam.NumParam[3].ValueToString);

            EntryFilterLongDescription = "the " + ToString() + " ";
            EntryFilterShortDescription = "the " + ToString() + " ";
            ExitFilterLongDescription = "the " + ToString() + " ";
            ExitFilterShortDescription = "the " + ToString() + " ";

            switch (IndParam.ListParam[0].Text)
            {
                case "The Range histogram rises":
                    EntryFilterLongDescription += "rises";
                    EntryFilterShortDescription += "falls";
                    ExitFilterLongDescription += "rises";
                    ExitFilterShortDescription += "falls";
                    break;

                case "The Range histogram falls":
                    EntryFilterLongDescription += "falls";
                    EntryFilterShortDescription += "rises";
                    ExitFilterLongDescription += "falls";
                    ExitFilterShortDescription += "rises";
                    break;

                case "The Range histogram is higher than the Level line":
                    EntryFilterLongDescription += "is higher than the Level " + sLevelLong;
                    EntryFilterShortDescription += "is lower than the Level " + sLevelShort;
                    ExitFilterLongDescription += "is higher than the Level " + sLevelLong;
                    ExitFilterShortDescription += "is lower than the Level " + sLevelShort;
                    break;

                case "The Range histogram is lower than the Level line":
                    EntryFilterLongDescription += "is lower than the Level " + sLevelLong;
                    EntryFilterShortDescription += "is higher than the Level " + sLevelShort;
                    ExitFilterLongDescription += "is lower than the Level " + sLevelLong;
                    ExitFilterShortDescription += "is higher than the Level " + sLevelShort;
                    break;

                case "The Range histogram crosses the Level line upward":
                    EntryFilterLongDescription += "crosses the Level " + sLevelLong + " upward";
                    EntryFilterShortDescription += "crosses the Level " + sLevelShort + " downward";
                    ExitFilterLongDescription += "crosses the Level " + sLevelLong + " upward";
                    ExitFilterShortDescription += "crosses the Level " + sLevelShort + " downward";
                    break;

                case "The Range histogram crosses the Level line downward":
                    EntryFilterLongDescription += "crosses the Level " + sLevelLong + " downward";
                    EntryFilterShortDescription += "crosses the Level " + sLevelShort + " upward";
                    ExitFilterLongDescription += "crosses the Level " + sLevelLong + " downward";
                    ExitFilterShortDescription += "crosses the Level " + sLevelShort + " upward";
                    break;

                case "The Range histogram changes its direction upward":
                    EntryFilterLongDescription += "changes its direction upward";
                    EntryFilterShortDescription += "changes its direction downward";
                    ExitFilterLongDescription += "changes its direction upward";
                    ExitFilterShortDescription += "changes its direction downward";
                    break;

                case "The Range histogram changes its direction downward":
                    EntryFilterLongDescription += "changes its direction downward";
                    EntryFilterShortDescription += "changes its direction upward";
                    ExitFilterLongDescription += "changes its direction downward";
                    ExitFilterShortDescription += "changes its direction upward";
                    break;

                default:
                    break;
            }

            return;
        }

        /// <summary>
        /// Indicator to string
        /// </summary>
        public override string ToString()
        {
            string sString = IndicatorName +
                (IndParam.CheckParam[0].Checked ? "* (" : " (") +
                IndParam.ListParam[1].Text + ", " + // Method
                IndParam.ListParam[2].Text + ", " + // Price
                IndParam.ListParam[3].Text + ", " + // Signal MA Method
                IndParam.NumParam[0].ValueToString + ", " + // Slow MA period
                IndParam.NumParam[1].ValueToString + ", " + // Fast MA period
                IndParam.NumParam[2].ValueToString + ")";   // Signal MA period

            return sString;
        }
    }
}