MQLArticles/Utils/FA/Atr.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+

//|                                                          Atr.mqh |

//|                                  Copyright 2025, Niquel Mendoza. |

//|                     https://www.mql5.com/es/users/nique_372/news |

//+------------------------------------------------------------------+

#property copyright "Copyright 2025, Niquel Mendoza."

#property link      "https://www.mql5.com/es/users/nique_372/news"

#property strict



#ifndef MQLARTICLES_UTILS_FA_ATR_MQH

#define MQLARTICLES_UTILS_FA_ATR_MQH



//+------------------------------------------------------------------+

//| Includes                                                         |

//+------------------------------------------------------------------+

#include "SimpleLogger.mqh"

#include "BarControler.mqh"



//+------------------------------------------------------------------+

//| Resources                                                        |

//+------------------------------------------------------------------+

#resource "AtrCts.ex5"



//+------------------------------------------------------------------+

//| Class to handle the atr                                          |

//+------------------------------------------------------------------+

class CAtr : public CLoggerBase

 {

private:

  double             arr[];

  ENUM_TIMEFRAMES    timeframe;

  int                handle;



public:

                    ~CAtr();

                     CAtr();



  //---

  inline bool        IsIdxValid(const int idx, const string& function_name) const;



  //---

  void               SetAsSeries(bool flag);

  bool               CopyData(int start, int count);

  bool               CopyData(int count);



  //---

  void               Create(ENUM_TIMEFRAMES tf, const string& symb, int period, bool execute_on_bar, bool hide_indicator = true);

  void               Create(const int handle_);

  bool               Sincronize(const int min_bars_calc, const int ms_sleep, int attemps = 100);



  //---

  inline ENUM_TIMEFRAMES Timeframe() const { return timeframe; }

  inline int         Handle() const        { return handle;    }

  void               Free()                { ArrayFree(arr);   }



  //---

  // Para evitar erroers use el check..

  double             operator[](int _index) const { return arr[_index]; }

 };



//+------------------------------------------------------------------+

//| Contructor and Destructor                                        |

//+------------------------------------------------------------------+

CAtr::CAtr(void)

  : handle(INVALID_HANDLE), timeframe(WRONG_VALUE)

 {

  ArrayResize(arr, 0);

 }

//+------------------------------------------------------------------+

CAtr::~CAtr()

 {

  if(handle != INVALID_HANDLE)

    IndicatorRelease(handle);

//Free();

 }



//+------------------------------------------------------------------+

//| Check index                                                      |

//+------------------------------------------------------------------+

inline bool        CAtr::IsIdxValid(const int idx, const string& function_name) const

 {

  if(int(arr.Size()) > idx && idx >= 0)

    return true;

  else

   {

    LogError(StringFormat("Acceso al array de atr denegado, indice %d fuera de rango, tama<00>o del array = %u", idx, arr.Size()), function_name);

    return false;

   }

 }



//+------------------------------------------------------------------+

bool CAtr::CopyData(int start, int count)

 {

  ResetLastError();

  if(CopyBuffer(handle, 0, start, count, arr) != count)

   {

    LogError(StringFormat("No se pudo copiar data del indicador de atr [start %d -> count: %d], ultimo error = %d", start, count, GetLastError()), FUNCION_ACTUAL);

    return false;

   }

// FastLog(FUNCION_ACTUAL, INFO_TEXT, StringFormat("El handle del indicador es %s", (handle == INVALID_HANDLE ? "invalido" : "valido")));

  return true;

 }





//+------------------------------------------------------------------+

bool CAtr::CopyData(int count)

 {

  ResetLastError();

  if(CopyBuffer(handle, 0, 0, count, arr) != count)

   {

    LogError(StringFormat("No se pudo copiar data del indicador de atr [0 -> count: %d], ultimo error = %d", count, GetLastError()), FUNCION_ACTUAL);

    return false;

    //FastLog(FUNCION_ACTUAL, INFO_TEXT, StringFormat("El handle del indicador es %s", (handle == INVALID_HANDLE ? "invalido" : "valido")));

   }

  return true;

 }





//+------------------------------------------------------------------+

void CAtr::Create(ENUM_TIMEFRAMES tf, const string& symb, int period, bool execute_on_bar, bool hide_indicator = true)

 {

  ResetLastError();



//---

  if(hide_indicator)

    TesterHideIndicators(true);



//---

  const int handle_ = iCustom(symb, (timeframe = tf), "::AtrCts.ex5", period, execute_on_bar);



//---

  if(hide_indicator)

    TesterHideIndicators(false);



//---

  if(handle_ == INVALID_HANDLE)

   {

    LogFatalError(StringFormat("No se pudo crear el handle para el indicador atr, ultimo error = %d", GetLastError()), FUNCION_ACTUAL);

    Remover();

   }

  else

   {

    this.handle = handle_;

   }

 }



//+------------------------------------------------------------------+

void CAtr::Create(const int handle_)

 {

  if(handle_ == INVALID_HANDLE)

   {

    LogFatalError(StringFormat("No se pudo crear el handle para el indicador atr, ultimo error = %d", GetLastError()), FUNCION_ACTUAL);

    Remover();

    return;

   }



//---

  this.handle = handle_;

 }



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

bool CAtr::Sincronize(const int min_bars_calc, const int ms_sleep, int attemps = 100)

 {

//---

  while(attemps-- > 0)

   {

    if(BarsCalculated(this.handle) >= min_bars_calc)

     {

      return true;

     }



    //---

    Sleep(ms_sleep);

   }



//---

  LogError(StringFormat("Fallo al obtener data del indicador Atr | # Intenos = %d | Min Bars = %d | SleepMs = %d", attemps, min_bars_calc, ms_sleep), FUNCION_ACTUAL);



//---

  return false;

 }





//+------------------------------------------------------------------+

void CAtr::SetAsSeries(bool flag)

 {

  ArraySetAsSeries(this.arr, flag);

 }



//+------------------------------------------------------------------+

bool DataIsValid(const double &arr[])

 {

  for(int i = 0; i < (int)arr.Size(); i++)

   {

    if(arr[i] == 0.00 || arr[i] == EMPTY_VALUE)

      return false;

   }

  return true;

 }





//+------------------------------------------------------------------+

//| Base class to implement the atr                                  |

//+------------------------------------------------------------------+

class CAtrOptimized : public CLoggerBase

 {

protected:

  ENUM_TIMEFRAMES    m_timeframe;

  string             m_symbol;

  int                m_index;

  int                m_period;

  double             m_atr_value;  // Valor ATR espec<EFBFBD>fico para m_index

  double             wilder_factor;

  double             inv_period;



  //---

  double             high[];

  double             low[];

  double             close[];

  double             atr[];



  //---

  CBarControler      controler_curr;

  inline double      CalculeTrueRange(int idx);

  inline double      CalculeTrueRangeForIndexCts(int index);

  bool               CopyData();



public:

                     CAtrOptimized(ENUM_TIMEFRAMES tf, const string& symbol, int index, int period);

                    ~CAtrOptimized(void);



  //---

  virtual inline double GetAtrValue(const datetime curr_time) = 0;

 };



//+------------------------------------------------------------------+

//| Constructor and destructor                                       |

//+------------------------------------------------------------------+

CAtrOptimized::CAtrOptimized(ENUM_TIMEFRAMES tf, const string& symbol, int index, int period)

  : controler_curr(tf)

 {

//---

  bool custom = false;

  if(!SymbolExist(symbol, custom))

   {

    LogFatalError(StringFormat("El simbolo %s, es invalido", symbol), FUNCION_ACTUAL);

    Remover();

    return;

   }

  if(period <= 0)

   {

    LogFatalError(StringFormat("El periodo del atr %d, es invalido", period), FUNCION_ACTUAL);

    Remover();

    return;

   }



//---

  m_timeframe = tf;

  m_symbol = symbol;

  m_index = index;

  m_period = period;

  m_atr_value = 0.0;

  wilder_factor = (double)(m_period - 1) / m_period;  // 13/14 para per<EFBFBD>odo 14

  inv_period = 1.0 / m_period;                        // 1/14 para per<EFBFBD>odo 14



//---

  ArraySetAsSeries(high, true);

  ArraySetAsSeries(low, true);

  ArraySetAsSeries(close, true);

  ArrayResize(high, 0);

  ArrayResize(low, 0);

  ArrayResize(close, 0);

  ArrayResize(atr, m_period + 2);

 }



//+------------------------------------------------------------------+

CAtrOptimized::~CAtrOptimized(void)

 {

 }



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

#define CopyAtrExtraValue 3

#define CopyAtr(p) p*2+CopyAtrExtraValue