MTF ADXW Indicator works fine and draws all lines correctly but after some time indicator buffers values became 0. Also indicator is very slow.

New comment
 

Hello,

I am trying to code MTF ADXW indicator. Below is my code which works fine and draws all lines correctly(See screenshot below) but after some time indicator buffers values became 0. Also indicator is very slow.
I hope somebody can give me suggestions and tell me whats wrong with my code.

Thanks in advanced.


#property indicator_separate_window
#property indicator_buffers 12
#property indicator_plots   12

input    int               N_Count           =  3;
input    ENUM_TIMEFRAMES   _1ADX_TimeFrame   =  PERIOD_CURRENT;
input    int               _1ADX_DMILength   =  14;
input    bool              _1ADX_Show_Main   =  true;
input    bool              _1ADX_Show_DMI    =  true;
input    ENUM_TIMEFRAMES   _2ADX_TimeFrame   =  PERIOD_CURRENT;
input    int               _2ADX_DMILength   =  14;
input    bool              _2ADX_Show_Main   =  true;
input    bool              _2ADX_Show_DMI    =  true;
input    ENUM_TIMEFRAMES   _3ADX_TimeFrame   =  PERIOD_CURRENT;
input    int               _3ADX_DMILength   =  14;
input    bool              _3ADX_Show_Main   =  true;
input    bool              _3ADX_Show_DMI    =  true;

int   _1ADX_Ind_handle;
int   _2ADX_Ind_handle;
int   _3ADX_Ind_handle;

double   _1ADX_Main_Buffer[];
double   _1ADX_P_Buffer[];
double   _1ADX_N_Buffer[];
double   _1ADX_Main_Color_Buffer[];

double   _2ADX_Main_Buffer[];
double   _2ADX_P_Buffer[];
double   _2ADX_N_Buffer[];
double   _2ADX_Main_Color_Buffer[];

double   _3ADX_Main_Buffer[];
double   _3ADX_P_Buffer[];
double   _3ADX_N_Buffer[];
double   _3ADX_Main_Color_Buffer[];

double   _1ADX_Main_Buffer_Temp[];
double   _1ADX_P_Buffer_Temp[];
double   _1ADX_N_Buffer_Temp[];
double   _1ADX_Main_Color_Buffer_Temp[];

double   _2ADX_Main_Buffer_Temp[];
double   _2ADX_P_Buffer_Temp[];
double   _2ADX_N_Buffer_Temp[];
double   _2ADX_Main_Color_Buffer_Temp[];

double   _3ADX_Main_Buffer_Temp[];
double   _3ADX_P_Buffer_Temp[];
double   _3ADX_N_Buffer_Temp[];
double   _3ADX_Main_Color_Buffer_Temp[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
//--- indicator buffers mapping
   //--- 1
   CF_1(0, _1ADX_Main_Buffer, _1ADX_Show_Main, clrBrown, 5);
   CF_1(1, _1ADX_P_Buffer, _1ADX_Show_DMI, clrWhite, 5);
   CF_1(2, _1ADX_N_Buffer, _1ADX_Show_DMI, clrGray, 5);
   CF_1(3, _1ADX_Main_Color_Buffer, _1ADX_Show_Main, clrYellow, 5);
   //--- 2
   CF_1(4, _2ADX_Main_Buffer, _2ADX_Show_Main, clrBrown, 3);
   CF_1(5, _2ADX_P_Buffer, _2ADX_Show_DMI, clrGreen, 3);
   CF_1(6, _2ADX_N_Buffer, _2ADX_Show_DMI, clrRed, 3);
   CF_1(7, _2ADX_Main_Color_Buffer, _2ADX_Show_Main, clrYellow, 3);
   //--- 3
   CF_1(8, _3ADX_Main_Buffer, _3ADX_Show_Main, clrBrown, 1);
   CF_1(9, _3ADX_P_Buffer, _3ADX_Show_DMI, clrGreen, 1);
   CF_1(10, _3ADX_N_Buffer, _3ADX_Show_DMI, clrRed, 1);
   CF_1(11, _3ADX_Main_Color_Buffer, _3ADX_Show_Main, clrYellow, 1);
//---
   //--- 1
   _1ADX_Ind_handle = iCustom(_Symbol, _1ADX_TimeFrame, "Examples/ADXW", _1ADX_DMILength);
   if(_1ADX_Ind_handle == INVALID_HANDLE)
   {
      Print("The creation of iCustom has failed: _1ADX_Ind_handle = ", INVALID_HANDLE, "\n", "Runtime error = ", GetLastError());
      return INIT_FAILED;
   }
   //--- 2
   _2ADX_Ind_handle = iCustom(_Symbol, _2ADX_TimeFrame, "Examples/ADXW", _2ADX_DMILength);
   if(_2ADX_Ind_handle == INVALID_HANDLE)
   {
      Print("The creation of iCustom has failed: _2ADX_Ind_handle = ", INVALID_HANDLE, "\n", "Runtime error = ", GetLastError());
      return INIT_FAILED;
   }
   //--- 3
   _3ADX_Ind_handle = iCustom(_Symbol, _3ADX_TimeFrame, "Examples/ADXW", _3ADX_DMILength);
   if(_3ADX_Ind_handle == INVALID_HANDLE)
   {
      Print("The creation of iCustom has failed: _3ADX_Ind_handle = ", INVALID_HANDLE, "\n", "Runtime error = ", GetLastError());
      return INIT_FAILED;
   }
//---
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Custom function N: 1                                             |
//+------------------------------------------------------------------+
void CF_1(int index, double& _XADX_X_Buffer[], bool show, color clr = clrBrown, int width = 1, string label = "")
{
   SetIndexBuffer(index, _XADX_X_Buffer, INDICATOR_DATA);
   PlotIndexSetInteger(index, PLOT_DRAW_TYPE, DRAW_LINE);
   PlotIndexSetInteger(index, PLOT_LINE_STYLE, STYLE_SOLID);
   if(!show)
   {
      clr = clrNONE;
   }
   PlotIndexSetInteger(index, PLOT_LINE_COLOR, clr);
   PlotIndexSetInteger(index, PLOT_LINE_WIDTH, width);
   PlotIndexSetString(index, PLOT_LABEL, label);
   PlotIndexSetDouble(index, PLOT_EMPTY_VALUE, EMPTY_VALUE);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
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[])
  {
//---
   int limit = rates_total - prev_calculated;
   //--- counting from 0 to rates_total
   //--- 1
   ArraySetAsSeries(_1ADX_Main_Buffer, true);
   ArraySetAsSeries(_1ADX_P_Buffer, true);
   ArraySetAsSeries(_1ADX_N_Buffer, true);
   ArraySetAsSeries(_1ADX_Main_Color_Buffer, true);
   //--- 2
   ArraySetAsSeries(_2ADX_Main_Buffer, true);
   ArraySetAsSeries(_2ADX_P_Buffer, true);
   ArraySetAsSeries(_2ADX_N_Buffer, true);
   ArraySetAsSeries(_2ADX_Main_Color_Buffer, true);
   //--- 3
   ArraySetAsSeries(_3ADX_Main_Buffer, true);
   ArraySetAsSeries(_3ADX_P_Buffer, true);
   ArraySetAsSeries(_3ADX_N_Buffer, true);
   ArraySetAsSeries(_3ADX_Main_Color_Buffer, true);
   //--- initial zero
   if(prev_calculated < 1)
   {
      //--- 1
      ArrayInitialize(_1ADX_Main_Buffer, 0);
      ArrayInitialize(_1ADX_P_Buffer, 0);
      ArrayInitialize(_1ADX_N_Buffer, 0);
      ArrayInitialize(_1ADX_Main_Color_Buffer, 0);
      //--- 2
      ArrayInitialize(_2ADX_Main_Buffer, 0);
      ArrayInitialize(_2ADX_P_Buffer, 0);
      ArrayInitialize(_2ADX_N_Buffer, 0);
      ArrayInitialize(_2ADX_Main_Color_Buffer, 0);
      //--- 3
      ArrayInitialize(_3ADX_Main_Buffer, 0);
      ArrayInitialize(_3ADX_P_Buffer, 0);
      ArrayInitialize(_3ADX_N_Buffer, 0);
      ArrayInitialize(_3ADX_Main_Color_Buffer, 0);
   }
   else
   {
      limit++;
   }
//---
   //--- 1
   if(BarsCalculated(_1ADX_Ind_handle) <= 0) { return(0); }
   if(CopyBuffer(_1ADX_Ind_handle, 0, 0, rates_total, _1ADX_Main_Buffer_Temp) <= 0) { return(rates_total); }
   ArraySetAsSeries(_1ADX_Main_Buffer_Temp, true);
   if(CopyBuffer(_1ADX_Ind_handle, 1, 0, rates_total, _1ADX_P_Buffer_Temp) <= 0) { return(rates_total); }
   ArraySetAsSeries(_1ADX_P_Buffer_Temp, true);
   if(CopyBuffer(_1ADX_Ind_handle, 2, 0, rates_total, _1ADX_N_Buffer_Temp) <= 0) { return(rates_total); }
   ArraySetAsSeries(_1ADX_N_Buffer_Temp, true);
   //--- 2
   if(BarsCalculated(_2ADX_Ind_handle) <= 0) { return(0); }
   if(CopyBuffer(_2ADX_Ind_handle, 0, 0, rates_total, _2ADX_Main_Buffer_Temp) <= 0) { return(rates_total); }
   ArraySetAsSeries(_2ADX_Main_Buffer_Temp, true);
   if(CopyBuffer(_2ADX_Ind_handle, 1, 0, rates_total, _2ADX_P_Buffer_Temp) <= 0) { return(rates_total); }
   ArraySetAsSeries(_2ADX_P_Buffer_Temp, true);
   if(CopyBuffer(_2ADX_Ind_handle, 2, 0, rates_total, _2ADX_N_Buffer_Temp) <= 0) { return(rates_total); }
   ArraySetAsSeries(_2ADX_N_Buffer_Temp, true);
   //--- 3
   if(BarsCalculated(_3ADX_Ind_handle) <= 0) { return(0); }
   if(CopyBuffer(_3ADX_Ind_handle, 0, 0, rates_total, _3ADX_Main_Buffer_Temp) <= 0) { return(rates_total); }
   ArraySetAsSeries(_3ADX_Main_Buffer_Temp, true);
   if(CopyBuffer(_3ADX_Ind_handle, 1, 0, rates_total, _3ADX_P_Buffer_Temp) <= 0) { return(rates_total); }
   ArraySetAsSeries(_3ADX_P_Buffer_Temp, true);
   if(CopyBuffer(_3ADX_Ind_handle, 2, 0, rates_total, _3ADX_N_Buffer_Temp) <= 0) { return(rates_total); }
   ArraySetAsSeries(_3ADX_N_Buffer_Temp, true);
//---
   //--- 1
   double _1ADX_Main_Buffer_Temp_Value =  0;
   double _1ADX_P_Buffer_Temp_Value    =  0;
   double _1ADX_N_Buffer_Temp_Value    =  0;
   //--- 2
   double _2ADX_Main_Buffer_Temp_Value =  0;
   double _2ADX_P_Buffer_Temp_Value    =  0;
   double _2ADX_N_Buffer_Temp_Value    =  0;
   //--- 3
   double _3ADX_Main_Buffer_Temp_Value =  0;
   double _3ADX_P_Buffer_Temp_Value    =  0;
   double _3ADX_N_Buffer_Temp_Value    =  0;
//---
   //--- main loop
   for(int i = limit - 1; i >= 0; i--)
   {
      if (i >= MathMin(5000 - 1, rates_total - 1 - 50))
      {
         // omit some old rates to prevent "Array out of range" or slow calculation
         continue;
      }
      //--- 1
      for(int j = i; j >= 0; j--)
      {
         if(iTime(_Symbol, _1ADX_TimeFrame, j) == iTime(_Symbol, _Period, i))
         {
            _1ADX_Main_Buffer[i]          = _1ADX_Main_Buffer_Temp[j];
            _1ADX_Main_Buffer_Temp_Value  = _1ADX_Main_Buffer[i];
            _1ADX_P_Buffer[i]             = _1ADX_P_Buffer_Temp[j];
            _1ADX_P_Buffer_Temp_Value     = _1ADX_P_Buffer[i];
            _1ADX_N_Buffer[i]             = _1ADX_N_Buffer_Temp[j];
            _1ADX_N_Buffer_Temp_Value     = _1ADX_N_Buffer[i];
            
            break;
         }
      }
      //---
      if(_1ADX_Main_Buffer_Temp_Value  > 0 && (_1ADX_Main_Buffer[i]  == EMPTY_VALUE || _1ADX_Main_Buffer[i] == 0)) { _1ADX_Main_Buffer[i] = _1ADX_Main_Buffer_Temp_Value;  }
      if(_1ADX_P_Buffer_Temp_Value     > 0 && (_1ADX_P_Buffer[i]     == EMPTY_VALUE || _1ADX_P_Buffer[i]    == 0)) { _1ADX_P_Buffer[i]    = _1ADX_P_Buffer_Temp_Value;     }
      if(_1ADX_N_Buffer_Temp_Value     > 0 && (_1ADX_N_Buffer[i]     == EMPTY_VALUE || _1ADX_N_Buffer[i]    == 0)) { _1ADX_N_Buffer[i]    = _1ADX_N_Buffer_Temp_Value;     }
      //--- 2
      for(int j = i; j >= 0; j--)
      {
         if(iTime(_Symbol, _2ADX_TimeFrame, j) == iTime(_Symbol, _Period, i))
         {
            _2ADX_Main_Buffer[i]          = _2ADX_Main_Buffer_Temp[j];
            _2ADX_Main_Buffer_Temp_Value  = _2ADX_Main_Buffer[i];
            _2ADX_P_Buffer[i]             = _2ADX_P_Buffer_Temp[j];
            _2ADX_P_Buffer_Temp_Value     = _2ADX_P_Buffer[i];
            _2ADX_N_Buffer[i]             = _2ADX_N_Buffer_Temp[j];
            _2ADX_N_Buffer_Temp_Value     = _2ADX_N_Buffer[i];
            
            break;
         }
      }
      //---
      if(_2ADX_Main_Buffer_Temp_Value  > 0 && (_2ADX_Main_Buffer[i]  == EMPTY_VALUE || _2ADX_Main_Buffer[i] == 0)) { _2ADX_Main_Buffer[i] = _2ADX_Main_Buffer_Temp_Value;  }
      if(_2ADX_P_Buffer_Temp_Value     > 0 && (_2ADX_P_Buffer[i]     == EMPTY_VALUE || _2ADX_P_Buffer[i]    == 0)) { _2ADX_P_Buffer[i]    = _2ADX_P_Buffer_Temp_Value;     }
      if(_2ADX_N_Buffer_Temp_Value     > 0 && (_2ADX_N_Buffer[i]     == EMPTY_VALUE || _2ADX_N_Buffer[i]    == 0)) { _2ADX_N_Buffer[i]    = _2ADX_N_Buffer_Temp_Value;     }
      //--- 3
      for(int j = i; j >= 0; j--)
      {
         if(iTime(_Symbol, _3ADX_TimeFrame, j) == iTime(_Symbol, _Period, i))
         {
            _3ADX_Main_Buffer[i]          = _3ADX_Main_Buffer_Temp[j];
            _3ADX_Main_Buffer_Temp_Value  = _3ADX_Main_Buffer[i];
            _3ADX_P_Buffer[i]             = _3ADX_P_Buffer_Temp[j];
            _3ADX_P_Buffer_Temp_Value     = _3ADX_P_Buffer[i];
            _3ADX_N_Buffer[i]             = _3ADX_N_Buffer_Temp[j];
            _3ADX_N_Buffer_Temp_Value     = _3ADX_N_Buffer[i];
            
            break;
         }
      }
      //---
      if(_3ADX_Main_Buffer_Temp_Value  > 0 && (_3ADX_Main_Buffer[i]  == EMPTY_VALUE || _3ADX_Main_Buffer[i] == 0)) { _3ADX_Main_Buffer[i] = _3ADX_Main_Buffer_Temp_Value;  }
      if(_3ADX_P_Buffer_Temp_Value     > 0 && (_3ADX_P_Buffer[i]     == EMPTY_VALUE || _3ADX_P_Buffer[i]    == 0)) { _3ADX_P_Buffer[i]    = _3ADX_P_Buffer_Temp_Value;     }
      if(_3ADX_N_Buffer_Temp_Value     > 0 && (_3ADX_N_Buffer[i]     == EMPTY_VALUE || _3ADX_N_Buffer[i]    == 0)) { _3ADX_N_Buffer[i]    = _3ADX_N_Buffer_Temp_Value;     }
      //---
      //---
      //---
      if(_1ADX_Main_Buffer[i] >= AVG_ADX(i, _1ADX_Main_Buffer, N_Count)) { _1ADX_Main_Color_Buffer[i] = _1ADX_Main_Buffer[i]; } else { _1ADX_Main_Color_Buffer[i] = EMPTY_VALUE; }
      if(_2ADX_Main_Buffer[i] >= AVG_ADX(i, _2ADX_Main_Buffer, N_Count)) { _2ADX_Main_Color_Buffer[i] = _2ADX_Main_Buffer[i]; } else { _2ADX_Main_Color_Buffer[i] = EMPTY_VALUE; }
      if(_3ADX_Main_Buffer[i] >= AVG_ADX(i, _3ADX_Main_Buffer, N_Count)) { _3ADX_Main_Color_Buffer[i] = _3ADX_Main_Buffer[i]; } else { _3ADX_Main_Color_Buffer[i] = EMPTY_VALUE; }
   }
//--- return value of prev_calculated for next call
   return(rates_total);
}
//+------------------------------------------------------------------+
double AVG_ADX(int index, double& _XADX_Main_Buffer[], int N)
{
   double AVG_XADX_Main_Buffer = 0;
   
   for(int i = index; i < index + N; i++)
   {
      AVG_XADX_Main_Buffer += _XADX_Main_Buffer[i];
   }
   
   return NormalizeDouble(AVG_XADX_Main_Buffer / N, _Digits);
}
//+------------------------------------------------------------------+
New comment
Reason: