//---------------------------------------------------------------------------------------------------------------------
#define     MName          "Exponential Range Average & Deviation Offset"
#define     MVersion       "1.0"
#define     MBuild         "2022-06-25 14:58 WEST"
#define     MCopyright     "Copyright \x00A9 2022, Fernando M. I. Carreiro, All rights reserved"
#define     MProfile       "https://www.mql5.com/en/users/FMIC"
//---------------------------------------------------------------------------------------------------------------------
#property   strict
#property   version        MVersion
#property   description    MName
#property   description    "MetaTrader Indicator (Build "MBuild")"
#property   copyright      MCopyright
#property   link           MProfile
//---------------------------------------------------------------------------------------------------------------------

//--- Setup

   #property indicator_separate_window

   // Define number of buffers and plots
      #define MPlots    2
      #define MBuffers  3
      #ifdef __MQL4__
         #property indicator_buffers   MPlots
      #else
         #property indicator_buffers   MBuffers
         #property indicator_plots     MPlots
      #endif

   // Display properties for plots
      #property indicator_label1 "Range Average"
      #property indicator_label2 "Deviation Offset"
      #property indicator_color1 C'38,166,154'
      #property indicator_color2 C'239,83,80'
      #property indicator_width1 1
      #property indicator_width2 1
      #property indicator_style1 STYLE_SOLID
      #property indicator_style2 STYLE_DOT
      #property indicator_type1  DRAW_LINE
      #property indicator_type2  DRAW_LINE

//--- Parameter settings

   input double   i_dbPeriod  = 13.0;   // Averaging period

//--- Macro definitions

   // Define OnCalculate loop sequencing macros
      #define MOnCalcPrevTest ( prev_calculated < 1 || prev_calculated > rates_total )
      #ifdef __MQL4__   // for MQL4 (as series)
         #define MOnCalcNext(  _index          ) ( _index--             )
         #define MOnCalcBack(  _index, _offset ) ( _index + _offset     )
         #define MOnCalcCheck( _index          ) ( _index >= 0          )
         #define MOnCalcValid( _index          ) ( _index < rates_total )
         #define MOnCalcStart \
            ( rates_total - ( MOnCalcPrevTest ? 1 : prev_calculated ) )
      #else             // for MQL5 (as non-series)
         #define MOnCalcNext(  _index          ) ( _index++             )
         #define MOnCalcBack(  _index, _offset ) ( _index - _offset     )
         #define MOnCalcCheck( _index          ) ( _index < rates_total )
         #define MOnCalcValid( _index          ) ( _index >= 0          )
         #define MOnCalcStart \
            ( MOnCalcPrevTest ? 0 : prev_calculated - 1 )
      #endif

   // Define macro for invalid parameter values
      #define MCheckParameter( _condition, _text ) if( _condition ) \
         { Print( "Error: Invalid ", _text ); return INIT_PARAMETERS_INCORRECT; }

   // Define macro for calculating and assigning exponential moving average
      #define MCalcEma( _var, _value, _weight ) \
         _var = _var##Prev + ( _value - _var##Prev ) * _weight

//--- Global variable declarations

   // Indicator buffers
      double
         g_adbRangeAverage[],    // Buffer for range average
         g_adbDeltaAverage[],    // Buffer for delta average
         g_adbDeviation[];       // Buffer for deviation offset

   // Miscellaneous global variables
      double
         g_dbEmaWeight;    // Weight to be used for exponential moving averages

//--- Event handling functions

   // Initialisation event handler
      int OnInit(void)
      {
         // Validate input parameters
            MCheckParameter( i_dbPeriod < DBL_EPSILON, "Averaging period!" );

         // Calculate parameter variables
            g_dbEmaWeight = 2.0 / ( i_dbPeriod + 1.0 );

         // Set number of significant digits (precision)
            IndicatorSetInteger( INDICATOR_DIGITS, _Digits );

         // Set buffers
            int iBuffer = 0;
            #ifdef __MQL4__
               IndicatorBuffers( MBuffers );   // Set total number of buffers (MQL4 Only)
            #endif
            SetIndexBuffer( iBuffer++, g_adbRangeAverage, INDICATOR_DATA         );
            SetIndexBuffer( iBuffer++, g_adbDeviation,    INDICATOR_DATA         );
            SetIndexBuffer( iBuffer++, g_adbDeltaAverage, INDICATOR_CALCULATIONS );

         // Set indicator name
            IndicatorSetString( INDICATOR_SHORTNAME,
               MName + " (" + DoubleToString( i_dbPeriod, 3 ) + ")" );

         return INIT_SUCCEEDED;  // Successful initialisation of indicator
      };

   // Calculation event handler
      int
         OnCalculate(
            const int      rates_total,
            const int      prev_calculated,
            const datetime &time[],
            const double   &open[],
            const double   &high[],
            const double   &low[],
            const double   &close[],
            const long     &tick_volume[],
            const long     &volume[],
            const int      &spread[]
         )
      {
         // Define local variables
            double
               dbHigh, dbLow, dbClosePrev,
               dbRange, dbRangeAverage, dbRangeAveragePrev,
               dbDelta, dbDeltaAverage, dbDeltaAveragePrev;

         // Main loop — fill in the arrays with data values
            for( int iCur  = MOnCalcStart, iPrev = MOnCalcBack( iCur, 1 );
                 !IsStopped() && MOnCalcCheck( iCur );
                 MOnCalcNext( iCur ), MOnCalcNext( iPrev ) )
            {
               // Get high and low price quotes
                  dbHigh = high[ iCur ];
                  dbLow  = low[  iCur ];

               // Calculate buffer values
                  if( MOnCalcValid( iPrev ) ) // Check if index is within array range
                  {
                     // Adjust for true range
                        dbClosePrev = close[ iPrev ];
                        if( dbClosePrev > dbHigh ) dbHigh = dbClosePrev;
                        if( dbClosePrev < dbLow )  dbLow  = dbClosePrev;

                     // Calculate range exponential moving average
                        dbRangeAveragePrev = g_adbRangeAverage[ iPrev ];
                        dbRange = dbHigh - dbLow;
                        MCalcEma( dbRangeAverage, dbRange, g_dbEmaWeight );

                     // Calculate delta exponential moving average
                        dbDeltaAveragePrev = g_adbDeltaAverage[ iPrev ];
                        dbDelta = dbRange - dbRangeAveragePrev;
                        MCalcEma( dbDeltaAverage, dbDelta, g_dbEmaWeight );
                  }
                  else
                  {
                     dbRangeAverage = dbHigh - dbLow;
                     dbDeltaAverage = 0;
                  };

               // Set buffer values
                  g_adbRangeAverage[ iCur ] = dbRangeAverage;
                  g_adbDeltaAverage[ iCur ] = dbDeltaAverage;
                  g_adbDeviation[    iCur ] = dbRangeAverage
                                            + dbDeltaAverage;
            };

         return rates_total;  // Return value for prev_calculated of next call
      };

//---------------------------------------------------------------------------------------------------------------------