ADX-and-DI/ADX_and_DI.mq4

<EFBFBD><EFBFBD>//T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
//Q% <EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W%<EFBFBD>%<EFBFBD>%W%  <EFBFBD>%<EFBFBD>%W% <EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W% <EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W% <EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W% <EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W%  <EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W% <EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W% <EFBFBD>%<EFBFBD>%<EFBFBD>%W%  <EFBFBD>%<EFBFBD>%W% Q%
//Q% <EFBFBD>%<EFBFBD>%T%P%P%P%]%Z%<EFBFBD>%<EFBFBD>%W%<EFBFBD>%<EFBFBD>%T%]%<EFBFBD>%<EFBFBD>%T%P%P%<EFBFBD>%<EFBFBD>%W%<EFBFBD>%<EFBFBD>%T%P%P%<EFBFBD>%<EFBFBD>%W%<EFBFBD>%<EFBFBD>%T%P%P%P%]%<EFBFBD>%<EFBFBD>%T%P%P%<EFBFBD>%<EFBFBD>%W%<EFBFBD>%<EFBFBD>%T%P%P%P%]%<EFBFBD>%<EFBFBD>%T%P%P%<EFBFBD>%<EFBFBD>%W%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W% <EFBFBD>%<EFBFBD>%Q% Q%
//Q% <EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W%  Z%<EFBFBD>%<EFBFBD>%<EFBFBD>%T%]% <EFBFBD>%<EFBFBD>%Q%  <EFBFBD>%<EFBFBD>%Q%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%T%]%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W% <EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%Q%<EFBFBD>%<EFBFBD>%Q%    <EFBFBD>%<EFBFBD>%Q%  <EFBFBD>%<EFBFBD>%Q%<EFBFBD>%<EFBFBD>%T%<EFBFBD>%<EFBFBD>%W%<EFBFBD>%<EFBFBD>%Q% Q%
//Q% <EFBFBD>%<EFBFBD>%T%P%P%]%  <EFBFBD>%<EFBFBD>%T%<EFBFBD>%<EFBFBD>%W% <EFBFBD>%<EFBFBD>%Q%  <EFBFBD>%<EFBFBD>%Q%<EFBFBD>%<EFBFBD>%T%P%P%<EFBFBD>%<EFBFBD>%W%<EFBFBD>%<EFBFBD>%T%P%P%]% <EFBFBD>%<EFBFBD>%T%P%P%<EFBFBD>%<EFBFBD>%Q%<EFBFBD>%<EFBFBD>%Q%    <EFBFBD>%<EFBFBD>%Q%  <EFBFBD>%<EFBFBD>%Q%<EFBFBD>%<EFBFBD>%Q%Z%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%Q% Q%
//Q% <EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W%<EFBFBD>%<EFBFBD>%T%]% <EFBFBD>%<EFBFBD>%W%Z%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%T%]%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%T%]%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W%<EFBFBD>%<EFBFBD>%Q%  <EFBFBD>%<EFBFBD>%Q%Z%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%W%Z%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%<EFBFBD>%T%]%<EFBFBD>%<EFBFBD>%Q% Z%<EFBFBD>%<EFBFBD>%<EFBFBD>%Q% Q%
//Q% Z%P%P%P%P%P%]%Z%P%]%  Z%P%]% Z%P%P%P%P%]% Z%P%P%P%P%P%]% Z%P%P%P%P%P%]%Z%P%]%  Z%P%]% Z%P%P%P%P%]% Z%P%P%P%P%]% Z%P%]%  Z%P%P%]% Q%
//Z%P%P%P%P%P%P%P% Algorithms that observe P%P%P%P% Signals that speak P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%]%
//+------------------------------------------------------------------+
//|          R<EFBFBD>plica fiel del indicador "ADX and DI" de BeikabuOyaji |
//|          TradingView Pine Script v4 <EFBFBD>! MQL4                       |
//|          Fuente: tradingview.com/script/VTPMMOrx-ADX-and-DI/     |
//|          Licencia original: Mozilla Public License 2.0           |
//+------------------------------------------------------------------+
//|  NOTAS T<EFBFBD>CNICAS:                                                 |
//|  - Suavizado Wilder (<EFBFBD>=1/N) para TR, +DM, -DM <EFBFBD>! DI+, DI-       |
//|  - SMA simple (media aritm<EFBFBD>tica ventana deslizante) para ADX     |
//|  - Esta combinaci<EFBFBD>n h<EFBFBD>brida NO coincide con el iADX nativo       |
//|    de MetaTrader 4 (que usa EMA para todo el c<EFBFBD>lculo)            |
//|  - Inicializaci<EFBFBD>n desde 0 (replica nz() de Pine Script)         |
//+------------------------------------------------------------------+
//|  DIFERENCIAS MQL4 vs MQL5 implementadas:                         |
//|  - #property indicator_buffers = solo plots visibles (3)         |
//|  - IndicatorBuffers() en init() para declarar el total (7)       |
//|  - SetIndexBuffer() sin tercer par<EFBFBD>metro de tipo                 |
//|  - SetIndexStyle() / SetIndexLabel() / SetIndexDrawBegin()       |
//|  - SetLevelValue() / SetLevelStyle() para l<EFBFBD>nea horizontal       |
//|  - Arrays en modo series por defecto <EFBFBD>! ArraySetAsSeries(false)   |
//|  - OnCalculate() compatible con MT4 build 600+                   |
//+------------------------------------------------------------------+

#property copyright   "Exobeacon Labs"
#property link        "https://www.exobeacon.com/"
#property version     "1.0"
#property description "ADX and DI (by BeikabuOyaji) v1.1"
#property description "Exact replica of BeikabuOyaji's ADX and DI indicator."
#property description "Uses Wilder smoothing for DI and SMA for ADX."
#property description " "
#property description "                       "
#property description "mql5.com/en/users/ulisescalb"
#property description "github.com/Exobeacon-Labs"
#property strict

#property indicator_separate_window
#property indicator_buffers  3     // MQL4: n<EFBFBD>mero de plots visibles
                                    // El total real (7) se declara con
                                    // IndicatorBuffers(7) en OnInit()

//--- Plot 0: DI+ (verde)
#property indicator_color1   clrGreen
#property indicator_style1   STYLE_SOLID
#property indicator_width1   1

//--- Plot 1: DI- (rojo)
#property indicator_color2   clrRed
#property indicator_style2   STYLE_SOLID
#property indicator_width2   1

//--- Plot 2: ADX (azul marino)
#property indicator_color3   clrNavy
#property indicator_style3   STYLE_SOLID
#property indicator_width3   2

//--- Nivel horizontal
#property indicator_level1     20
#property indicator_levelcolor clrBlack
#property indicator_levelstyle STYLE_SOLID

//+------------------------------------------------------------------+
//| Par<EFBFBD>metros de entrada                                            |
//|  len <EFBFBD>! InpPeriod  (per<EFBFBD>odo de suavizado y SMA)                   |
//|  th  <EFBFBD>! InpThreshold (l<EFBFBD>nea horizontal de referencia)             |
//+------------------------------------------------------------------+
input int InpPeriod    = 14;  // Per<EFBFBD>odo (len)
input int InpThreshold = 20;  // Umbral horizontal (th)

//+------------------------------------------------------------------+
//| Buffers globales                                                 |
//+------------------------------------------------------------------+
//--- Buffers de datos (visibles en Data Window y accesibles v<EFBFBD>a iCustom)
double DIPlusBuffer[];          // Buffer 0 <EFBFBD>! Plot 0: DI+
double DIMinusBuffer[];         // Buffer 1 <EFBFBD>! Plot 1: DI-
double ADXBuffer[];             // Buffer 2 <EFBFBD>! Plot 2: ADX

//--- Buffers de c<EFBFBD>lculo interno (no visibles, no accesibles v<EFBFBD>a iCustom)
double SmoothedTRBuffer[];      // Buffer 3: True Range suavizado (Wilder)
double SmoothedDMPlusBuffer[];  // Buffer 4: +DM suavizado (Wilder)
double SmoothedDMMinusBuffer[]; // Buffer 5: -DM suavizado (Wilder)
double DXBuffer[];              // Buffer 6: DX (entrada para SMA <EFBFBD>! ADX)

//+------------------------------------------------------------------+
//| Inicializaci<EFBFBD>n del indicador                                     |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Validaci<EFBFBD>n de par<EFBFBD>metros
   if(InpPeriod < 1)
     {
      PrintFormat("ADXandDI: Error - Per<00>odo (%d) debe ser >= 1", InpPeriod);
      return(INIT_PARAMETERS_INCORRECT);
     }

//--- MQL4: declarar el n<EFBFBD>mero TOTAL de buffers (visibles + c<EFBFBD>lculo)
//    #property indicator_buffers solo declara los visibles (3)
//    IndicatorBuffers() establece el total real (7)
   IndicatorBuffers(7);

//--- Asignar buffers visibles (<EFBFBD>ndices 0-2: accesibles v<EFBFBD>a iCustom)
   SetIndexBuffer(0, DIPlusBuffer);
   SetIndexBuffer(1, DIMinusBuffer);
   SetIndexBuffer(2, ADXBuffer);

//--- Asignar buffers de c<EFBFBD>lculo interno (<EFBFBD>ndices 3-6: no accesibles)
   SetIndexBuffer(3, SmoothedTRBuffer);
   SetIndexBuffer(4, SmoothedDMPlusBuffer);
   SetIndexBuffer(5, SmoothedDMMinusBuffer);
   SetIndexBuffer(6, DXBuffer);

//--- MQL4: configurar estilo de cada plot con SetIndexStyle()
//    Equivale a #property indicator_type + color + style + width en MQL5
   SetIndexStyle(0, DRAW_LINE, STYLE_SOLID, 1, clrGreen);
   SetIndexStyle(1, DRAW_LINE, STYLE_SOLID, 1, clrRed);
   SetIndexStyle(2, DRAW_LINE, STYLE_SOLID, 2, clrNavy);

//--- MQL4: etiquetas para Data Window (equivale a indicator_label en MQL5)
   SetIndexLabel(0, "DI+");
   SetIndexLabel(1, "DI-");
   SetIndexLabel(2, "ADX");

//--- Ocultar buffers de c<EFBFBD>lculo en Data Window
   SetIndexLabel(3, NULL);
   SetIndexLabel(4, NULL);
   SetIndexLabel(5, NULL);
   SetIndexLabel(6, NULL);

//--- MQL4: configurar inicio de dibujo
//    DI+/DI- necesitan ~InpPeriod barras para converger
//    ADX = SMA(DX, InpPeriod) necesita InpPeriod valores de DX adicionales
   SetIndexDrawBegin(0, InpPeriod);       // DI+
   SetIndexDrawBegin(1, InpPeriod);       // DI-
   SetIndexDrawBegin(2, InpPeriod * 2);   // ADX

//--- MQL4: valor vac<EFBFBD>o para barras sin datos
   SetIndexEmptyValue(0, EMPTY_VALUE);
   SetIndexEmptyValue(1, EMPTY_VALUE);
   SetIndexEmptyValue(2, EMPTY_VALUE);

//--- MQL4: configurar nivel horizontal din<EFBFBD>micamente seg<EFBFBD>n par<EFBFBD>metro th
   SetLevelValue(0, (double)InpThreshold);
   SetLevelStyle(STYLE_SOLID, 1, clrBlack);

//--- MQL4: precisi<EFBFBD>n de decimales
   IndicatorDigits(2);

//--- MQL4: nombre corto del indicador
   IndicatorShortName("ADX and DI (" + IntegerToString(InpPeriod) + ")");

   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Funci<EFBFBD>n principal de c<EFBFBD>lculo                                     |
//|                                                                  |
//| NOTA MQL4: Los arrays de precio (high[], low[], close[]) y los   |
//| buffers del indicador est<EFBFBD>n en modo AS_SERIES por defecto en     |
//| MQL4, es decir, <EFBFBD>ndice 0 = barra m<EFBFBD>s reciente. Para mantener    |
//| la l<EFBFBD>gica id<EFBFBD>ntica al c<EFBFBD>digo MQL5 (donde 0 = barra m<EFBFBD>s antigua),|
//| desactivamos el modo series con ArraySetAsSeries(array, false).  |
//|                                                                  |
//| Algoritmo (r<EFBFBD>plica del Pine Script de BeikabuOyaji):             |
//| 1. True Range = max(H-L, |H-C[1]|, |L-C[1]|)                   |
//| 2. +DM / -DM con exclusividad mutua de Wilder                   |
//| 3. Suavizado Wilder: S(i) = S(i-1) - S(i-1)/len + valor        |
//| 4. DI+ = SmoothedDM+ / SmoothedTR * 100                         |
//|    DI- = SmoothedDM- / SmoothedTR * 100                          |
//| 5. DX  = |DI+ - DI-| / (DI+ + DI-) * 100                       |
//| 6. ADX = SMA(DX, len)  <EFBFBD>! <EFBFBD>SMA simple, NO Wilder/SMMA!          |
//+------------------------------------------------------------------+
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[])
  {
//--- Verificar datos m<EFBFBD>nimos (necesitamos al menos 2 barras)
   if(rates_total < 2)
      return(0);

//=================================================================
//  CR<EFBFBD>TICO MQL4: Desactivar modo series en TODOS los arrays
//  MQL4 indexa arrays como series por defecto (0 = m<EFBFBD>s reciente)
//  Necesitamos indexaci<EFBFBD>n regular (0 = m<EFBFBD>s antiguo) para mantener
//  la misma l<EFBFBD>gica que MQL5 y Pine Script
//=================================================================
   ArraySetAsSeries(time, false);
   ArraySetAsSeries(open, false);
   ArraySetAsSeries(high, false);
   ArraySetAsSeries(low, false);
   ArraySetAsSeries(close, false);
   ArraySetAsSeries(tick_volume, false);
   ArraySetAsSeries(volume, false);
   ArraySetAsSeries(spread, false);

//--- Tambi<EFBFBD>n los buffers del indicador
   ArraySetAsSeries(DIPlusBuffer, false);
   ArraySetAsSeries(DIMinusBuffer, false);
   ArraySetAsSeries(ADXBuffer, false);
   ArraySetAsSeries(SmoothedTRBuffer, false);
   ArraySetAsSeries(SmoothedDMPlusBuffer, false);
   ArraySetAsSeries(SmoothedDMMinusBuffer, false);
   ArraySetAsSeries(DXBuffer, false);

   int start;

//=================================================================
//  FASE 1: True Range, Movimiento Direccional, Suavizado Wilder,
//          DI+, DI-, DX
//=================================================================

   if(prev_calculated == 0)
     {
      //--- Primera ejecuci<EFBFBD>n completa: inicializar barra 0
      //    Pine Script nz() retorna 0 para valores inexistentes,
      //    as<EFBFBD> que los buffers suavizados empiezan desde 0
      SmoothedTRBuffer[0]      = 0.0;
      SmoothedDMPlusBuffer[0]  = 0.0;
      SmoothedDMMinusBuffer[0] = 0.0;
      DIPlusBuffer[0]          = 0.0;
      DIMinusBuffer[0]         = 0.0;
      DXBuffer[0]              = 0.0;
      ADXBuffer[0]             = EMPTY_VALUE;
      start = 1;
     }
   else
     {
      //--- Recalcular solo la <EFBFBD>ltima barra (o desde donde se qued<EFBFBD>)
      start = prev_calculated - 1;
     }

//--- Bucle principal: indexaci<EFBFBD>n de izquierda a derecha (0 = m<EFBFBD>s antigua)
//    gracias a ArraySetAsSeries(false) aplicado arriba
   for(int i = start; i < rates_total && !IsStopped(); i++)
     {
      //-------------------------------------------------------
      // 1. True Range: max(H-L, |H-C<EFBFBD> <EFBFBD> |, |L-C<EFBFBD> <EFBFBD> |)
      //-------------------------------------------------------
      double prev_close = close[i - 1];
      double tr = MathMax(MathMax(high[i] - low[i],
                                  MathAbs(high[i] - prev_close)),
                          MathAbs(low[i] - prev_close));

      //-------------------------------------------------------
      // 2. Movimiento Direccional (+DM, -DM)
      //    Regla de exclusividad mutua de Wilder
      //-------------------------------------------------------
      double up_move   = high[i] - high[i - 1];
      double down_move = low[i - 1] - low[i];

      double dm_plus, dm_minus;

      if(up_move > down_move && up_move > 0.0)
         dm_plus = up_move;
      else
         dm_plus = 0.0;

      if(down_move > up_move && down_move > 0.0)
         dm_minus = down_move;
      else
         dm_minus = 0.0;

      //-------------------------------------------------------
      // 3. Suavizado de Wilder (forma running sum)
      //    S(i) = S(i-1) - S(i-1)/len + valor
      //-------------------------------------------------------
      double prev_str  = SmoothedTRBuffer[i - 1];
      double prev_sdmp = SmoothedDMPlusBuffer[i - 1];
      double prev_sdmm = SmoothedDMMinusBuffer[i - 1];

      SmoothedTRBuffer[i]      = prev_str  - prev_str  / InpPeriod + tr;
      SmoothedDMPlusBuffer[i]  = prev_sdmp - prev_sdmp / InpPeriod + dm_plus;
      SmoothedDMMinusBuffer[i] = prev_sdmm - prev_sdmm / InpPeriod + dm_minus;

      //-------------------------------------------------------
      // 4. DI+ y DI- (en porcentaje)
      //-------------------------------------------------------
      double smoothed_tr = SmoothedTRBuffer[i];

      if(smoothed_tr > 0.0)
        {
         DIPlusBuffer[i]  = SmoothedDMPlusBuffer[i]  / smoothed_tr * 100.0;
         DIMinusBuffer[i] = SmoothedDMMinusBuffer[i] / smoothed_tr * 100.0;
        }
      else
        {
         DIPlusBuffer[i]  = 0.0;
         DIMinusBuffer[i] = 0.0;
        }

      //-------------------------------------------------------
      // 5. DX = |DI+ - DI-| / (DI+ + DI-) * 100
      //-------------------------------------------------------
      double di_sum = DIPlusBuffer[i] + DIMinusBuffer[i];

      if(di_sum > 0.0)
         DXBuffer[i] = MathAbs(DIPlusBuffer[i] - DIMinusBuffer[i]) / di_sum * 100.0;
      else
         DXBuffer[i] = 0.0;
     }

//=================================================================
//  FASE 2: ADX = SMA(DX, len)
//  Media aritm<EFBFBD>tica simple de ventana deslizante sobre DX
//  <EFBFBD>CR<EFBFBD>TICO: es SMA, NO Wilder/SMMA/RMA!
//=================================================================

   int adx_first_bar = InpPeriod;  // Primera barra con ADX v<EFBFBD>lido
   int adx_start;

   if(prev_calculated == 0)
     {
      //--- Marcar todas las barras sin ADX v<EFBFBD>lido
      for(int i = 0; i < MathMin(adx_first_bar, rates_total); i++)
         ADXBuffer[i] = EMPTY_VALUE;

      //--- Verificar que hay suficientes barras
      if(rates_total <= adx_first_bar)
         return(rates_total);

      //--- Calcular el primer valor de ADX como SMA de DX[1..InpPeriod]
      double sum = 0.0;
      for(int j = 1; j <= InpPeriod; j++)
         sum += DXBuffer[j];
      ADXBuffer[adx_first_bar] = sum / InpPeriod;

      adx_start = adx_first_bar + 1;
     }
   else
     {
      adx_start = MathMax(prev_calculated - 1, adx_first_bar + 1);
     }

//--- Calcular SMA incremental para las barras restantes
//    SMA(i) = SMA(i-1) + (DX[i] - DX[i-InpPeriod]) / InpPeriod
   for(int i = adx_start; i < rates_total && !IsStopped(); i++)
     {
      double new_val = DXBuffer[i];
      double old_val = DXBuffer[i - InpPeriod];
      ADXBuffer[i] = ADXBuffer[i - 1] + (new_val - old_val) / InpPeriod;
     }

   return(rates_total);
  }
//+------------------------------------------------------------------+