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);

  inline void        CopyData(int start, int count);

  inline void        CopyData(int count);



  //---

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

  void               Create(int handle_);



  //---

  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;

   }

 }



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

inline void 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);

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

 }





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

inline void 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);

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

 }





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

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

 {

  ResetLastError();



  if(hide_indicator)

    TesterHideIndicators(true);



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



  if(hide_indicator)

    TesterHideIndicators(false);



  Create(handle_);

 }



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

void CAtr::Create(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_;

  int16_t atemps = 250;

  double dummy[100];



//---

  while(atemps-- > 0)

   {

    //--- Copiamos

    if(CopyBuffer(handle, 0, 0, 100, dummy) != 100)

      continue;



    //--- Verificamos que la data sea valida

    if(DataIsValid(dummy))

      break;

   }

 }



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

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)

 {

//---

  bool custom = false;

  if(SymbolExist(symbol, custom) == false)

   {

    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;

  controler_curr = new CBarControler(tf);

  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)

 {

//ArrayFree(high);

//ArrayFree(low);

//ArrayFree(close);

//ArrayFree(atr);

  if(CheckPointer(controler_curr) == POINTER_DYNAMIC && controler_curr != NULL)

    delete controler_curr;

 }



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

//|                                                                  |

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

#define CopyAtrExtraValue 3

#define CopyAtr(p) p*2+CopyAtrExtraValue



//---

bool CAtrOptimized::CopyData()

 {

  int to_copy = CopyAtr(m_period);



  if(CopyHigh(this.m_symbol, this.m_timeframe, m_index, to_copy, high) < to_copy)

   {

    LogError(StringFormat("Al copiar data de los highs, start = %d - count = %d", m_index, to_copy), FUNCION_ACTUAL);

    return false;

   }



  if(CopyClose(this.m_symbol, this.m_timeframe, m_index, to_copy, close) < to_copy)

   {

    LogError(StringFormat("Al copiar data de los closes start = %d - count = %d", m_index, to_copy), FUNCION_ACTUAL);

    return false;