MQLArticles/RM/RM_Functions.mqh

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

//|                                                RMt_Functions.mqh |

//|                                     Niquel y Leo, Copyright 2025 |

//|                                             https://www.mql5.com |

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

#property copyright "Niquel y Leo, Copyright 2025"

#property link  "https://www.mql5.com"

#property strict



#ifndef MQLARTICLES_RM_RFUNCTIONS_MQH

#define MQLARTICLES_RM_RFUNCTIONS_MQH



#include "LoteSizeCalc.mqh"



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

//+-----------------------------------        Functions        -------------------------------------+

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

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

double GetPositionCommission(ulong ticket)

 {

// Verificar si la posici<EFBFBD>n existe y obtener su tiempo de apertura

  if(!PositionSelectByTicket(ticket))

   {

    Print("Error: Posici<00>n con ticket ", ticket, " no encontrada");

    return 0.0;

   }

  datetime open_time = (datetime)PositionGetInteger(POSITION_TIME);



// Usar un rango de tiempo estrecho: desde el tiempo de apertura hasta 1 segundo despu<EFBFBD>s

  if(!HistorySelect(open_time, open_time + 1))

   {

    Print("Error: No se pudo cargar el historial de deals para el ticket ", ticket);

    return 0.0;

   }



// Obtener el primer deal del historial

  ulong deal_ticket = HistoryDealGetTicket(0);

  if(deal_ticket == 0)

   {

    Print("Error: No se encontr<00> un deal para el ticket ", ticket);

    return 0.0;

   }



// Verificar si el deal corresponde a la posici<EFBFBD>n y es de entrada

  if(HistoryDealGetInteger(deal_ticket, DEAL_POSITION_ID) == ticket)

   {

    ENUM_DEAL_TYPE deal_type = (ENUM_DEAL_TYPE)HistoryDealGetInteger(deal_ticket, DEAL_TYPE);

    if(deal_type == DEAL_TYPE_BUY || deal_type == DEAL_TYPE_SELL)

     {

      return HistoryDealGetDouble(deal_ticket, DEAL_COMMISSION);

     }

   }



  Print("Error: No se encontr<00> un deal de apertura v<00>lido para el ticket ", ticket);

  return 0.0;

 }





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

inline CGetLote* CreateLotePtr(string symbol)

 {

  CGetLote* l = new CGetLote(symbol);

  return l;

 }



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

double GetTotalPositionProfitNoCurrent(ulong position_ticket)

 {

  double total_profit = 0.0;



//---

  if(HistorySelectByPosition(position_ticket))

   {

    int deals_count = HistoryDealsTotal();



    for(int i = 0; i < deals_count; i++)

     {

      ulong deal_ticket = HistoryDealGetTicket(i);

      if(deal_ticket <= 0)

        continue;



      ENUM_DEAL_ENTRY entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(deal_ticket, DEAL_ENTRY);



      if(entry == DEAL_ENTRY_OUT || entry == DEAL_ENTRY_IN)

       {

        total_profit += HistoryDealGetDouble(deal_ticket, DEAL_PROFIT) +

                        HistoryDealGetDouble(deal_ticket, DEAL_SWAP) +

                        HistoryDealGetDouble(deal_ticket, DEAL_COMMISSION);

       }

     }

   }



  return total_profit;

 }



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

//|        Retrieve the magic number associated with a ticket        |

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

inline ulong GetMagic(const ulong ticket)

 {

  HistoryOrderSelect(ticket);

  return HistoryOrderGetInteger(ticket, ORDER_MAGIC);

 }







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

//| Calculates the net profit since a given date for a specific magic number or all trades |

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

const bool GetNetProfitOmitirDeal[18] =

 {

  false, //compra

  false, //venta

  true, //balance

  true, //credito

  true, //carga adicionales

  false,  //correcion

  true, //bonos

  false, //comisiones adicional

  false, //comisions del dia

  false, //comision del mes

  false, //comosions agente dia

  false, //comosiion agenet mes,

  false, //interes

  false, //compra cancelada

  false, //ventan cancelada

  false, //dividendo

  false, //dividendo frankeado, con beneficions

  false //impuestos

 };



//---

double GetNetProfitSince(bool include_all_magic, ulong specific_magic, datetime start_date)

 {

  double total_net_profit = 0.0; // Initialize the total net profit

  ResetLastError(); // Reset any previous errors



//---

  if(start_date > 0 && start_date != D'1971.01.01 00:00')

   {

    if(!HistorySelect(start_date, TimeCurrent()))

     {

      Print("Error when selecting orders: ", _LastError);

      return 0.00; // Exit if unable to select the history

     }



    const int total_deals = HistoryDealsTotal(); // Count total deals in the history



    for(int i = 0; i < total_deals; i++)

     {

      const ulong deal_ticket = HistoryDealGetTicket(i); // Get the deal ticket



      if(GetNetProfitOmitirDeal[HistoryDealGetInteger(deal_ticket, DEAL_TYPE)])

        continue;



      //---

      const ulong deal_magic = HistoryDealGetInteger(deal_ticket, DEAL_MAGIC);

      if(!include_all_magic && deal_magic != specific_magic)

        continue;



      //---

      const double deal_profit = HistoryDealGetDouble(deal_ticket, DEAL_PROFIT);

      const double deal_commission = HistoryDealGetDouble(deal_ticket, DEAL_COMMISSION);

      const double deal_swap = HistoryDealGetDouble(deal_ticket, DEAL_SWAP);

      total_net_profit += (deal_profit + deal_commission + deal_swap);

     }

   }



//---

  return total_net_profit;

 }





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

//| Function to close orders                                         |

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

// Converts an order type to its corresponding flag

#define  OrderTypeToFlag(type) OrdensToFlagArray[type]





const int ALL_FLAGS_STOPS = FLAG_ORDER_TYPE_BUY_STOP | FLAG_ORDER_TYPE_SELL_STOP;

const int ALL_FLAGS_LIMITS = FLAG_ORDER_TYPE_BUY_LIMIT | FLAG_ORDER_TYPE_SELL_LIMIT;

const int ALL_FLAGS_ORDERS = (FLAG_ORDER_TYPE_BUY | FLAG_ORDER_TYPE_SELL | FLAG_ORDER_TYPE_BUY_LIMIT |

                              FLAG_ORDER_TYPE_SELL_LIMIT | FLAG_ORDER_TYPE_BUY_STOP | FLAG_ORDER_TYPE_SELL_STOP |

                              FLAG_ORDER_TYPE_BUY_STOP_LIMIT | FLAG_ORDER_TYPE_SELL_STOP_LIMIT | FLAG_ORDER_TYPE_CLOSE_BY);





// Close all orders that match the flags in `flags`

void CloseAllOrders(int flags, CTrade & obj_trade, ulong magic_number_ = NOT_MAGIC_NUMBER)

 {

  ResetLastError();

  for(int i = OrdersTotal() - 1; i >= 0; i--)

   {

    ulong ticket = OrderGetTicket(i);



    if(OrderSelect(ticket))

     {

      ENUM_ORDER_TYPE type_order = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);

      ulong magic = OrderGetInteger(ORDER_MAGIC);

      int bandera = OrderTypeToFlag(type_order);

      if((bandera & flags) != 0 && (magic == magic_number_ || magic_number_ == NOT_MAGIC_NUMBER))

       {

        if(type_order == ORDER_TYPE_BUY || type_order == ORDER_TYPE_SELL)

          obj_trade.PositionClose(ticket);

        else

          obj_trade.OrderDelete(ticket);

       }

     }

    else

     {

      PrintFormat("Error selecting order %d, last error %d", ticket, GetLastError());

     }

   }

 }



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

//| Function to obtain the positions opened by the EA or user        |

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

int PositionTypeToFlag(ENUM_POSITION_TYPE type)

 {

  if(type == POSITION_TYPE_BUY)

    return FLAG_POSITION_TYPE_BUY;

  else

    if(type == POSITION_TYPE_SELL)

      return FLAG_POSITION_TYPE_SELL;



  return FLAG_POSITION_TYPE_BUY | FLAG_POSITION_TYPE_SELL;

 }



//---

int Get_Positions(int flags = FLAG_POSITION_TYPE_BUY | FLAG_POSITION_TYPE_SELL, ulong magic_number_ = NOT_MAGIC_NUMBER)

 {

  int counter = 0;



  for(int i = PositionsTotal() - 1; i >= 0; i--)

   {

    ulong position_ticket = PositionGetTicket(i);

    if(!PositionSelectByTicket(position_ticket))

      continue; // Si la selecci<EFBFBD>n falla, pasa a la siguiente posici<EFBFBD>n

    ulong position_magic = PositionGetInteger(POSITION_MAGIC);

    ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);

    // Check if the position type matches the flags

    if((flags & PositionTypeToFlag(type)) != 0 &&

       (position_magic == magic_number_ || magic_number_ == NOT_MAGIC_NUMBER))

     {

      counter++;

     }

   }



  return counter;

 }



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

//|                                                                  |

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

template<typename T>

bool RemoveIndexFromAnArrayOfPositions(T & array[], const ulong ticket, int reserve)

 {

  const int size = ArraySize(array);

  int index = -1;

// Search index and move elements in a single loop

  for(int i = 0; i < size; i++)

   {

    if(array[i].ticket == ticket)

     {

      index = i;

     }

    if(index != -1 && i < size - 1)

     {

      array[i] = array[i + 1]; // Move the elements

     }

   }



  if(index == -1)

    return false;



// Reducir el tama<EFBFBD>o del array

  ArrayResize(array, size - 1, reserve);

  return true;

 }





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

//|                                                                  |

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

void PrintArrayAsTable(double & array[], string fila_descripcion, string columna_prefijo = "Valor")

 {

  string header = fila_descripcion;

  int len = StringLen(header);

  string values = StringRepeat(" ", len + 2);



  int max_len = StringLen(header);

  for(int i = 0; i < ArraySize(array); i++)

   {

    string col_name = columna_prefijo + " " + IntegerToString(i + 1);

    max_len = MathMax(max_len, StringLen(col_name));

   }



  header = StringFormat("%-" + (string)(max_len + 2) + "s", header);



  for(int i = 0; i < ArraySize(array); i++)

   {

    string col_name = columna_prefijo + " " + IntegerToString(i + 1);

    header += StringFormat("| %-10s ", col_name);

    values += StringFormat("| %-10.2f ", array[i]);

   }



  Print(header);

  Print(values);

 }



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

//|                                                                  |

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

void SetDynamicUsingFixedParameters(

  double _balance_percentage_to_activate_the_risk_1, double _balance_percentage_to_activate_the_risk_2, double _balance_percentage_to_activate_the_risk_3, double _balance_percentage_to_activate_the_risk_4,

  double _percentage_to_be_modified_1, double _percentage_to_be_modified_2, double _percentage_to_be_modified_3, double _percentage_to_be_modified_4,

  string & percentages_to_activate, string & risks_to_be_applied)

 {

  percentages_to_activate = DoubleToString(_balance_percentage_to_activate_the_risk_1) + "," + DoubleToString(_balance_percentage_to_activate_the_risk_2) + "," + DoubleToString(_balance_percentage_to_activate_the_risk_3)

                            + "," + DoubleToString(_balance_percentage_to_activate_the_risk_4);

  risks_to_be_applied = DoubleToString(_percentage_to_be_modified_1) + "," + DoubleToString(_percentage_to_be_modified_2) + "," + DoubleToString(_percentage_to_be_modified_3)

                        + "," + DoubleToString(_percentage_to_be_modified_4);

 }









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

//| Clase CTicketsInfo                                               |

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

Position EMPTY_POSITION;



//---

class CTicketsInfo : public CLoggerBase

 {

private:

  //--- Data

  Position           m_positions[];



  //--- Hash

  uint16_t           m_hash_table[];

  bool               m_hash_filled[];

  uint16_t           m_hash_size;

  uint16_t           m_hash_count;



  //--- Static

  static const float LOAD_FACTOR_LIMIT;

  static const uint16_t INITIAL_HASH_SIZE;



  //--- Internal functions

  int16_t            FindHash(const ulong ticket) const;

  bool               InsertHash(ulong ticket, uint16_t pos_idx);

  bool               RemoveHash(ulong ticket);

  void               UpdateHashAfterSwap(ulong ticket, uint16_t new_pos_idx);

  void               ResizeHashTable();

  bool               IsPrime(uint16_t n);



public:

                     CTicketsInfo(void);

                    ~CTicketsInfo(void);



  //--- Data

  // Get

  bool               GetByTicket(const ulong ticket, Position& pos, int16_t& out_idx) const;

  bool               GetByTicket(const ulong ticket, Position& pos) const;

  inline Position    GetByTicket(const ulong ticket) const;

  inline Position    GetByIndex(const int16_t index) const { return m_positions[index]; }



  // Delete

  bool               DeleteByIndex(const int16_t pos_idx);

  bool               DeleteByTicket(const ulong ticket);

  bool               DeleteByTicket(const ulong ticket, Position &position);



  // Add

  bool               Add(Position &p);



  // Update

  inline void        UpdatePositionPartial(double net, double close_volume, int16_t pos_idx);

  inline void        UpdateTp(double new_tp, ulong ticket);

  inline void        UpdateSl(double new_sl, ulong ticket);





  //--- General Getters

  // Index

  inline bool        IsValidIdx(int16_t index) const; // Is Valid index

  __forceinline int  GetIndex(const ulong ticket) const { return FindHash(ticket);}



  // Total

  __forceinline int16_t Total()  const { return (int16_t)ArraySize(m_positions); }

  __forceinline uint16_t TotalU() const { return (uint16_t)m_positions.Size(); }



  //--- Exist

  inline bool        Exists(const ulong ticket) const;



  //--- Free

  void               Free();

 };



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

//|                                                                  |

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

const float CTicketsInfo::LOAD_FACTOR_LIMIT = 0.7f;

const uint16_t CTicketsInfo::INITIAL_HASH_SIZE = 9973;

#define  CTicketsInfo_HashTicket(ticket) uint16_t(ticket % m_hash_size)



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

//|                                                                  |

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

CTicketsInfo::CTicketsInfo(void) : m_hash_size(INITIAL_HASH_SIZE), m_hash_count(0)

 {

  ArrayResize(m_hash_table, m_hash_size);

  ArrayResize(m_hash_filled, m_hash_size);

  ArrayInitialize(m_hash_table, 65535);

  ArrayInitialize(m_hash_filled, false);

 }



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

CTicketsInfo::~CTicketsInfo(void)

 {

  ArrayFree(m_positions);

  ArrayFree(m_hash_table);

  ArrayFree(m_hash_filled);

 }



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

//|                                                                  |

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

inline bool CTicketsInfo::IsValidIdx(int16_t index) const

 {

  if(index >= 0 && index < Total())

    return true;

  LogError(StringFormat("El <00>ndice %d es inv<00>lido", index), FUNCION_ACTUAL);

  return false;

 }



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

int16_t CTicketsInfo::FindHash(const ulong ticket) const

 {