MQLArticles/Account/RM/RiskManagement/LPMods/Examples.mqh
Nique_372 Nique_372 87640cc853
2026-11-07 21:17:58 -05:00
481 lines
17 KiB
MQL5
//+------------------------------------------------------------------+
//| Modificators.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_ACCOUNT_RM_RISKMANAGEMENT_LPMODS_EXAMPLES_MQH
#define MQLARTICLES_ACCOUNT_RM_RISKMANAGEMENT_LPMODS_EXAMPLES_MQH
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//--- definicion
#include "Def.mqh"
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
namespace TSN
{
//+------------------------------------------------------------------+
//| Clase para aumentar el riesgo |
//+------------------------------------------------------------------+
enum ENUM_MULTIPLIER_METHOD_DR
{
DR_MULTIPLIER = 0, // Multiplier
DR_EXPONECIAL = 1, // Exponential
DR_SUMATORIO = 2 // Additive (Summation)
};
//--- Clase
class CDynamicRisk : public CExtraModifications
{
private:
double paso;
double val;
double percentage_a_empezar_modfiicacioneS;
ENUM_MULTIPLIER_METHOD_DR metod;
void Aumentar();
bool is_set;
public:
CDynamicRisk(double step, double percentage_to_empezar, ENUM_TYPE_LOSS_PROFIT property_to_modify, ENUM_MULTIPLIER_METHOD_DR multiplier_);
//---
void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final;
void OnIBalance(const double b) override final;
};
//+------------------------------------------------------------------+
CDynamicRisk::CDynamicRisk(double step, double percentage_to_empezar, ENUM_TYPE_LOSS_PROFIT property_to_modify, ENUM_MULTIPLIER_METHOD_DR multiplier_)
: CExtraModifications(property_to_modify, RISK_MANAGEMENT_EVENT_ON_CLOSE_POSITION | RISK_MANAGEMENT_EVENT_ON_INFO, "Risk enhancer by default")
{
//---
paso = step;
percentage_a_empezar_modfiicacioneS = percentage_to_empezar;
metod = multiplier_;
is_set = false;
//---
switch(metod)
{
case DR_MULTIPLIER:
break;
case DR_EXPONECIAL:
break;
case DR_SUMATORIO:
paso /= 100.0; // digmoas si el paso es de 10 suma de 0.10 en 0.10
break;
default:
{
LogFatalError(StringFormat("The method %s is invalid", EnumToString(metod)), FUNCION_ACTUAL);
Remover();
break;
}
}
}
//+------------------------------------------------------------------+
void CDynamicRisk::OnIBalance(const double b)
{
percentage_a_empezar_modfiicacioneS /= 100.0;
percentage_a_empezar_modfiicacioneS *= b;
Print("Balance to increase risk: ", percentage_a_empezar_modfiicacioneS);
val = m_modifier.GetCalcValue();
//Print("Valor del porcentaje: ", val);
}
//+------------------------------------------------------------------+
void CDynamicRisk::OnClosePosition(const ModifierOnOpenCloseStruct & on_open_close_struct, const ROnClosePosition& pos)
{
if(pos.position.profit > 0 && on_open_close_struct.profit_total > percentage_a_empezar_modfiicacioneS)
{
LogInfo(StringFormat("By increasing the risk, a profit of %.2f has been obtained. The initial balance has been exceeded by %.2f.",
pos.position.profit, percentage_a_empezar_modfiicacioneS), FUNCION_ACTUAL);
Aumentar();
m_modifier.SetCalcValue(val);
}
else
{
m_modifier.SetInitialCalcValue();
val = m_modifier.GetInitialCalcValue();
}
}
//+------------------------------------------------------------------+
void CDynamicRisk::Aumentar(void)
{
switch(metod)
{
case DR_MULTIPLIER:
val *= paso;
break;
case DR_EXPONECIAL:
val *= MathExp(paso);
break;
case DR_SUMATORIO:
val += paso;
break;
default:
break;
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
class CModificatorOscar : public CExtraModifications
{
private:
double max_risk;
double riesgo_inciial;
double fat_mul;
double prev_risk;
int hora_ny_init;
int min_ny_inti;
datetime hora_pa;
datetime hora_pd;
public:
CModificatorOscar(double max_risk_percent, double risk_init_percent, double multiplicator_, int init_ny_h, int init_ny_min);
~CModificatorOscar();
//---
void OnNewDay(const datetime curr_time) override final;
void OnIBalance(const double b) override final;
void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final;
};
//+------------------------------------------------------------------+
CModificatorOscar::CModificatorOscar(double max_risk_percent, double risk_init_percent, double multiplicator_, int init_ny_h, int init_ny_min)
: CExtraModifications(LP_GMLPO, RISK_MANAGEMENT_EVENT_ON_CLOSE_POSITION | RISK_MANAGEMENT_EVENT_ON_INFO, "Modifier by oscar")
{
max_risk = max_risk_percent;
riesgo_inciial = risk_init_percent;
fat_mul = multiplicator_;
hora_ny_init = init_ny_h;
min_ny_inti = init_ny_min;
//--- Registrar evento de nuevo dia
CBasicEvents::RegisterEvent(GetPointer(this), TSNQMALRT_BASIEVENT_TYPE_ON_NEW_DAY);
}
//+------------------------------------------------------------------+
CModificatorOscar::~CModificatorOscar()
{
if(CBasicEvents::IsActive())
CBasicEvents::UnregisterEvent(GetPointer(this), TSNQMALRT_BASIEVENT_TYPE_ON_NEW_DAY);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CModificatorOscar::OnNewDay(const datetime curr_time)
{
datetime hora_ny = HoraYMinutoADatetime(hora_ny_init, min_ny_inti, curr_time);
hora_pa = hora_ny - 60;
hora_pd = hora_ny + 60;
}
//+------------------------------------------------------------------+
void CModificatorOscar::OnIBalance(const double b)
{
riesgo_inciial /= 100.0;
riesgo_inciial *= b;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CModificatorOscar::OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos)
{
bool es_perdida = pos.position.profit < 0.00;
bool cerro_por_sl = pos.deal_reason == DEAL_REASON_SL;
bool cerro_por_tp = pos.deal_reason == DEAL_REASON_TP;
bool cerrado_en_ny = TimeCurrent() >= hora_pa && TimeCurrent() <= hora_pd;
//---
if(cerrado_en_ny)
{
LogInfo("Operation closed during NY hours - current risk remains", FUNCION_ACTUAL);
return;
}
//---
if(es_perdida && cerro_por_sl)
{
LogInfo(StringFormat("SL reached - increasing risk. Loss: %.2f", pos.position.profit), FUNCION_ACTUAL);
double new_risk = m_modifier.GetCalcValue() * fat_mul;
if(new_risk <= max_risk)
m_modifier.SetCalcValue(new_risk);
else
m_modifier.SetCalcValue(max_risk);
}
else
if(!es_perdida && cerro_por_tp)
{
LogInfo("TP reached - resetting to initial risk", FUNCION_ACTUAL);
m_modifier.SetInitialCalcValue();
}
}
//+--------------------------------------------------------------------------------------+
//| Clase para modificar el riesgo en base a la estrategia de 2.0 |
//+--------------------------------------------------------------------------------------+
class CModifierDynamicRisk : public CExtraModifications
{
private:
double to_applied[];
int index_gmlpo;
int to_applied_s;
public:
CModifierDynamicRisk(string percentages_to_applied);
//---
void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final;
};
//+------------------------------------------------------------------+
CModifierDynamicRisk::CModifierDynamicRisk(string percentages_to_applied)
: CExtraModifications(LP_GMLPO, RISK_MANAGEMENT_EVENT_ON_CLOSE_POSITION, "Dynamic Risk 2.0")
{
//---
to_applied_s = TSN::CStringFunc::ToArr<double, TSN::CStringConvert>(percentages_to_applied, to_applied, ',');
for(int i = 0; i < to_applied_s; i++)
to_applied[i] /= 100.0;
//---
// ArrayResize(to_applied, s);
//---
index_gmlpo = 0;
}
//+------------------------------------------------------------------+
void CModifierDynamicRisk::OnClosePosition(const ModifierOnOpenCloseStruct & on_open_close_struct, const ROnClosePosition& pos)
{
if(pos.position.profit < 0.00) //La posicion salio SL
{
// Print(__FUNCTION__, "Se a obtenido un sl modificando el riesgo...");
m_modifier.SetCalcValue(to_applied[index_gmlpo]);
if(index_gmlpo < to_applied_s - 1)
index_gmlpo++;
}
else //La posicion salio TP
{
//Print(__FUNCTION__, "Se a obtenido un tp modificando el riesgo...");
index_gmlpo = 0;
m_modifier.SetInitialCalcValue(); //Modificar al riesgo inicial
}
}
//+------------------------------------------------------------------+
//| Modificador de riesgo 2 |
//+------------------------------------------------------------------+
class CDynamicRiskAlma : public CExtraModifications
{
private:
double multiplier;
public:
CDynamicRiskAlma(double mul)
: CExtraModifications(LP_GMLPO, RISK_MANAGEMENT_EVENT_ON_CLOSE_POSITION, "Dynamic Risk Alma v2") { multiplier = mul; }
//---
void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final;
};
//+------------------------------------------------------------------+
void CDynamicRiskAlma::OnClosePosition(const ModifierOnOpenCloseStruct & on_open_close_struct, const ROnClosePosition& pos)
{
if(on_open_close_struct.profit_total < 0)
{
const double r = m_modifier.GetCalcValue() * multiplier;
m_modifier.SetCalcValue(r);
}
else
{
m_modifier.SetInitialCalcValue();
}
}
//+------------------------------------------------------------------+
//| Clase para modificar riesgo 3 |
//+------------------------------------------------------------------+
inline double FunctionKevin(double defect_risk, double loss_percentage, double constante)
{
return (defect_risk * MathExp(loss_percentage / constante));
}
//+------------------------------------------------------------------+
class CMathDynamicRisk : public CExtraModifications
{
private:
double constante;
double balance_inicial;
public:
CMathDynamicRisk(double constante_);
//---
void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final;
void OnIBalance(const double b) override final;
};
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
CMathDynamicRisk::CMathDynamicRisk(double constante_)
: CExtraModifications(LP_GMLPO, RISK_MANAGEMENT_EVENT_ON_CLOSE_POSITION | RISK_MANAGEMENT_EVENT_ON_INFO, "Modifier By Kevin")
{
constante = constante_;
}
//+------------------------------------------------------------------+
void CMathDynamicRisk::OnIBalance(const double b)
{
balance_inicial = b;
}
//+------------------------------------------------------------------+
void CMathDynamicRisk::OnClosePosition(const ModifierOnOpenCloseStruct & on_open_close_struct, const ROnClosePosition& pos)
{
if(on_open_close_struct.profit_total < 0.00)
{
const double percentage_ = CalcularPorcentaje(on_open_close_struct.profit_total, balance_inicial);
const double new_v = TSNMQLART_RISKM_NORM_PERCERNTAGE(
FunctionKevin(TSNMQLART_RISKM_NORM_TO_PERCENTAGE(m_modifier.GetInitialCalcValue()), percentage_, constante));
m_modifier.SetCalcValue(new_v);
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
class CDynamicFOptimal : public CExtraModifications
{
private:
int num_pos; // Número total de posiciones cerradas
double profit[]; // Profits de operaciones ganadoras
double loss[]; // Pérdidas (valor absoluto)
double sum_profit; // Suma acumulada de profits
double sum_loss; // Suma acumulada de pérdidas
double avg_profit; // Promedio de profits
double avg_loss; // Promedio de pérdidas
double rr; // Relación ganancia/pérdida (R)
double win_probability; // Probabilidad de ganar (p)
int min_trades; // Mínimo de operaciones para Kelly
double kelly_fraction; // Fracción de Kelly (por ejemplo, 0.5)
int max_data; // Máximo número de operaciones a almacenar
bool enable_kelly_mod; // Agregar como variable de clase
public:
CDynamicFOptimal(int min_trades_, int max_data_to_update, double kelly_fraction_)
: CExtraModifications(LP_GMLPO, RISK_MANAGEMENT_EVENT_ON_CLOSE_POSITION, "Optimal F Modifier")
{
num_pos = 0;
sum_profit = 0.0;
sum_loss = 0.0;
avg_profit = 0.0;
avg_loss = 0.0;
rr = 0.0;
win_probability = 0.0;
min_trades = MathMax(min_trades_, 10);
kelly_fraction = MathMax(0.0, MathMin(kelly_fraction_, 1.0)); // Corregir
max_data = MathMax(max_data_to_update, 30);
enable_kelly_mod = true;
ArrayResize(profit, 0);
ArrayResize(loss, 0);
}
void TrimOldData()
{
int total_data = ArraySize(profit) + ArraySize(loss);
if(total_data <= max_data)
return;
while(total_data > max_data)
{
if(ArraySize(profit) > 0 && (ArraySize(loss) == 0 || profit[0] <= loss[0]))
{
sum_profit -= profit[0];
ArrayRemove(profit, 0, 1);
int win_count = ArraySize(profit);
avg_profit = win_count > 0 ? sum_profit / win_count : 0.0;
num_pos--; // Decrementar
}
else
if(ArraySize(loss) > 0)
{
sum_loss -= loss[0];
ArrayRemove(loss, 0, 1);
int loss_count = ArraySize(loss);
avg_loss = loss_count > 0 ? sum_loss / loss_count : 0.0;
num_pos--; // Decrementar
}
total_data = ArraySize(profit) + ArraySize(loss);
}
}
void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final
{
double profit_value = pos.position.profit;
num_pos++;
if(profit_value == 0)
{
Print("Break-even operation detected");
return;
}
if(profit_value > 0)
{
AddArrayNoVerification(profit, profit_value, 0);
sum_profit += profit_value;
int win_count = ArraySize(profit);
avg_profit = win_count > 0 ? sum_profit / win_count : 0.0;
}
else
{
double val = fabs(profit_value);
AddArrayNoVerification(loss, val, 0);
sum_loss += fabs(profit_value);
int loss_count = ArraySize(loss);
avg_loss = loss_count > 0 ? sum_loss / loss_count : 0.0;
}
TrimOldData();
int win_count = ArraySize(profit);
int total_data = ArraySize(profit) + ArraySize(loss);
win_probability = total_data > 0 ? (double)win_count / total_data : 0.0;
rr = avg_loss > 0 ? avg_profit / avg_loss : 0.0;
PrintFormat("%s: Debug | win_count: %d, loss_count: %d, avg_profit: %.2f, avg_loss: %.2f", __FUNCTION__, ArraySize(profit), ArraySize(loss), avg_profit, avg_loss);
if(enable_kelly_mod && num_pos >= min_trades && rr > 0 && win_probability > 0)
{
double kelly = (win_probability * (rr + 1) - 1) / rr;
kelly = MathMax(0.0, MathMin(kelly, 1.0));
double adjusted_kelly = kelly * kelly_fraction;
m_modifier.SetCalcValue(adjusted_kelly);
PrintFormat("%s: Info | Kelly ajustado: %+.2f, Probabilidad: %.2f, R: %.2f, Operaciones: %d", __FUNCTION__, adjusted_kelly * 100.0, win_probability, rr, num_pos);
}
}
};
//---
}
//+------------------------------------------------------------------+
#endif // MQLARTICLES_ACCOUNT_RM_RISKMANAGEMENT_LPMODS_EXAMPLES_MQH
//+------------------------------------------------------------------+