2026-10-27 18:07:28 -05:00 | | | //+------------------------------------------------------------------+
|
| | | //| 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
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| |
|
| | | //+------------------------------------------------------------------+
|
2026-11-07 21:17:58 -05:00 | | | //--- definicion
|
2026-10-27 18:07:28 -05:00 | | | #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_);
|
| | |
|
| | | //---
|
2026-11-07 21:17:58 -05:00 | | | void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final;
|
| | | void OnIBalance(const double b) override final;
|
2026-10-27 18:07:28 -05:00 | | | };
|
| | | //+------------------------------------------------------------------+
|
| | | CDynamicRisk::CDynamicRisk(double step, double percentage_to_empezar, ENUM_TYPE_LOSS_PROFIT property_to_modify, ENUM_MULTIPLIER_METHOD_DR multiplier_)
|
2026-11-07 21:17:58 -05:00 | | | : CExtraModifications(property_to_modify, RISK_MANAGEMENT_EVENT_ON_CLOSE_POSITION | RISK_MANAGEMENT_EVENT_ON_INFO, "Risk enhancer by default")
|
2026-10-27 18:07:28 -05:00 | | | {
|
2026-11-02 21:51:46 -05:00 | | | //---
|
2026-10-27 18:07:28 -05:00 | | | paso = step;
|
| | | percentage_a_empezar_modfiicacioneS = percentage_to_empezar;
|
| | | metod = multiplier_;
|
| | | is_set = false;
|
| | |
|
2026-11-02 21:51:46 -05:00 | | | //---
|
| | | switch(metod)
|
2026-10-27 18:07:28 -05:00 | | | {
|
2026-11-02 21:51:46 -05:00 | | | 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;
|
| | | }
|
2026-10-27 18:07:28 -05:00 | | | }
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-11-07 21:17:58 -05:00 | | | void CDynamicRisk::OnIBalance(const double b)
|
2026-10-27 18:07:28 -05:00 | | | {
|
| | | percentage_a_empezar_modfiicacioneS /= 100.0;
|
2026-11-07 21:17:58 -05:00 | | | percentage_a_empezar_modfiicacioneS *= b;
|
2026-10-27 18:07:28 -05:00 | | | Print("Balance to increase risk: ", percentage_a_empezar_modfiicacioneS);
|
| | | val = m_modifier.GetCalcValue();
|
| | | //Print("Valor del porcentaje: ", val);
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-11-07 21:17:58 -05:00 | | | void CDynamicRisk::OnClosePosition(const ModifierOnOpenCloseStruct & on_open_close_struct, const ROnClosePosition& pos)
|
2026-10-27 18:07:28 -05:00 | | | {
|
2026-11-07 21:17:58 -05:00 | | | if(pos.position.profit > 0 && on_open_close_struct.profit_total > percentage_a_empezar_modfiicacioneS)
|
2026-10-27 18:07:28 -05:00 | | | {
|
| | | LogInfo(StringFormat("By increasing the risk, a profit of %.2f has been obtained. The initial balance has been exceeded by %.2f.",
|
2026-11-07 21:17:58 -05:00 | | | pos.position.profit, percentage_a_empezar_modfiicacioneS), FUNCION_ACTUAL);
|
2026-10-27 18:07:28 -05:00 | | | Aumentar();
|
| | | m_modifier.SetCalcValue(val);
|
| | | }
|
| | | else
|
| | | {
|
2026-10-27 19:06:42 -05:00 | | | m_modifier.SetInitialCalcValue();
|
| | | val = m_modifier.GetInitialCalcValue();
|
2026-10-27 18:07:28 -05:00 | | | }
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
| | | 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;
|
2026-11-07 21:17:58 -05:00 | | | void OnIBalance(const double b) override final;
|
| | | void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final;
|
2026-10-27 18:07:28 -05:00 | | | };
|
| | |
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | CModificatorOscar::CModificatorOscar(double max_risk_percent, double risk_init_percent, double multiplicator_, int init_ny_h, int init_ny_min)
|
2026-11-07 21:17:58 -05:00 | | | : CExtraModifications(LP_GMLPO, RISK_MANAGEMENT_EVENT_ON_CLOSE_POSITION | RISK_MANAGEMENT_EVENT_ON_INFO, "Modifier by oscar")
|
2026-10-27 18:07:28 -05:00 | | | {
|
| | | 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
|
2026-11-02 06:40:25 -05:00 | | | CBasicEvents::RegisterEvent(GetPointer(this), TSNQMALRT_BASIEVENT_TYPE_ON_NEW_DAY);
|
2026-10-27 18:07:28 -05:00 | | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | CModificatorOscar::~CModificatorOscar()
|
| | | {
|
| | | if(CBasicEvents::IsActive())
|
2026-11-02 06:40:25 -05:00 | | | CBasicEvents::UnregisterEvent(GetPointer(this), TSNQMALRT_BASIEVENT_TYPE_ON_NEW_DAY);
|
2026-10-27 18:07:28 -05:00 | | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | 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;
|
| | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
2026-11-07 21:17:58 -05:00 | | | void CModificatorOscar::OnIBalance(const double b)
|
2026-10-27 18:07:28 -05:00 | | | {
|
| | | riesgo_inciial /= 100.0;
|
2026-11-07 21:17:58 -05:00 | | | riesgo_inciial *= b;
|
2026-10-27 18:07:28 -05:00 | | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| |
|
| | | //+------------------------------------------------------------------+
|
2026-11-07 21:17:58 -05:00 | | | void CModificatorOscar::OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos)
|
2026-10-27 18:07:28 -05:00 | | | {
|
2026-11-07 21:17:58 -05:00 | | | 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;
|
2026-10-27 18:07:28 -05:00 | | | 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)
|
| | | {
|
2026-11-07 21:17:58 -05:00 | | | LogInfo(StringFormat("SL reached - increasing risk. Loss: %.2f", pos.position.profit), FUNCION_ACTUAL);
|
2026-10-27 18:07:28 -05:00 | | | 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;
|
2026-11-02 21:51:46 -05:00 | | | int to_applied_s;
|
2026-10-27 18:07:28 -05:00 | | |
|
| | | public:
|
| | | CModifierDynamicRisk(string percentages_to_applied);
|
| | |
|
| | | //---
|
2026-11-07 21:17:58 -05:00 | | | void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final;
|
2026-10-27 18:07:28 -05:00 | | | };
|
| | | //+------------------------------------------------------------------+
|
| | | CModifierDynamicRisk::CModifierDynamicRisk(string percentages_to_applied)
|
| | | : CExtraModifications(LP_GMLPO, RISK_MANAGEMENT_EVENT_ON_CLOSE_POSITION, "Dynamic Risk 2.0")
|
| | | {
|
2026-11-02 21:51:46 -05:00 | | | //---
|
| | | 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);
|
| | |
|
| | | //---
|
2026-10-27 18:07:28 -05:00 | | | index_gmlpo = 0;
|
| | | }
|
| | | //+------------------------------------------------------------------+
|
2026-11-07 21:17:58 -05:00 | | | void CModifierDynamicRisk::OnClosePosition(const ModifierOnOpenCloseStruct & on_open_close_struct, const ROnClosePosition& pos)
|
2026-10-27 18:07:28 -05:00 | | | {
|
2026-11-07 21:17:58 -05:00 | | | if(pos.position.profit < 0.00) //La posicion salio SL
|
2026-10-27 18:07:28 -05:00 | | | {
|
| | | // Print(__FUNCTION__, "Se a obtenido un sl modificando el riesgo...");
|
| | | m_modifier.SetCalcValue(to_applied[index_gmlpo]);
|
| | |
|
2026-11-02 21:51:46 -05:00 | | | if(index_gmlpo < to_applied_s - 1)
|
2026-10-27 18:07:28 -05:00 | | | 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; }
|
| | |
|
| | | //---
|
2026-11-07 21:17:58 -05:00 | | | void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final;
|
2026-10-27 18:07:28 -05:00 | | |
|
| | | };
|
| | |
|
| | | //+------------------------------------------------------------------+
|
2026-11-07 21:17:58 -05:00 | | | void CDynamicRiskAlma::OnClosePosition(const ModifierOnOpenCloseStruct & on_open_close_struct, const ROnClosePosition& pos)
|
2026-10-27 18:07:28 -05:00 | | | {
|
| | | if(on_open_close_struct.profit_total < 0)
|
| | | {
|
2026-11-02 21:51:46 -05:00 | | | const double r = m_modifier.GetCalcValue() * multiplier;
|
2026-10-27 18:07:28 -05:00 | | | 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:
|
2026-11-07 21:17:58 -05:00 | | | CMathDynamicRisk(double constante_);
|
2026-10-27 18:07:28 -05:00 | | |
|
| | | //---
|
2026-11-07 21:17:58 -05:00 | | | void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final;
|
| | | void OnIBalance(const double b) override final;
|
2026-10-27 18:07:28 -05:00 | | | };
|
| | |
|
| | | //+------------------------------------------------------------------+
|
2026-11-07 21:17:58 -05:00 | | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | 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)
|
2026-10-27 18:07:28 -05:00 | | | {
|
2026-11-07 21:17:58 -05:00 | | | balance_inicial = b;
|
2026-10-27 18:07:28 -05:00 | | | }
|
| | |
|
| | | //+------------------------------------------------------------------+
|
2026-11-07 21:17:58 -05:00 | | | void CMathDynamicRisk::OnClosePosition(const ModifierOnOpenCloseStruct & on_open_close_struct, const ROnClosePosition& pos)
|
2026-10-27 18:07:28 -05:00 | | | {
|
2026-11-02 21:51:46 -05:00 | | | if(on_open_close_struct.profit_total < 0.00)
|
2026-10-27 18:07:28 -05:00 | | | {
|
2026-11-02 21:51:46 -05: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);
|
2026-10-27 18:07:28 -05:00 | | | }
|
| | | }
|
| | |
|
| | |
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | 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:
|
2026-11-07 21:17:58 -05:00 | | | CDynamicFOptimal(int min_trades_, int max_data_to_update, double kelly_fraction_)
|
| | | : CExtraModifications(LP_GMLPO, RISK_MANAGEMENT_EVENT_ON_CLOSE_POSITION, "Optimal F Modifier")
|
2026-10-27 18:07:28 -05:00 | | | {
|
| | | 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);
|
| | | }
|
| | | }
|
| | |
|
2026-11-07 21:17:58 -05:00 | | | void OnClosePosition(const ModifierOnOpenCloseStruct &on_open_close_struct, const ROnClosePosition& pos) override final
|
2026-10-27 18:07:28 -05:00 | | | {
|
2026-11-07 21:17:58 -05:00 | | | double profit_value = pos.position.profit;
|
2026-10-27 18:07:28 -05:00 | | | 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;
|
2026-11-02 21:51:46 -05:00 | | | m_modifier.SetCalcValue(adjusted_kelly);
|
2026-10-27 18:07:28 -05:00 | | | PrintFormat("%s: Info | Kelly ajustado: %+.2f, Probabilidad: %.2f, R: %.2f, Operaciones: %d", __FUNCTION__, adjusted_kelly * 100.0, win_probability, rr, num_pos);
|
| | | }
|
| | | }
|
| | | };
|
| | |
|
2026-11-07 21:17:58 -05:00 | | | //---
|
2026-10-27 18:07:28 -05:00 | | | }
|
| | | //+------------------------------------------------------------------+
|
| | | #endif // MQLARTICLES_ACCOUNT_RM_RISKMANAGEMENT_LPMODS_EXAMPLES_MQH
|
| | | //+------------------------------------------------------------------+
|