forked from nique_372/MQLArticles
//+------------------------------------------------------------------+
| |
//| 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
| |
//+------------------------------------------------------------------+
|