| //+------------------------------------------------------------------+
|
| //| Base.mqh |
|
| //| Copyright 2025, Niquel Mendoza. |
|
| //| https://www.mql5.com/es/users/nique_372 |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2025, Niquel Mendoza."
|
| #property link "https://www.mql5.com/es/users/nique_372"
|
| #property strict
|
|
|
|
|
| #ifndef MQLARTICLES_RM_LOSSPROFIT_BASE_MQH
|
| #define MQLARTICLES_RM_LOSSPROFIT_BASE_MQH
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| Include |
|
| //+------------------------------------------------------------------+
|
| #include "..\\RiskManagementBases.mqh"
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| class CLossProfit; // Advance declaration for the typedef
|
|
|
| //+------------------------------------------------------------------+
|
| //| Defines |
|
| //+------------------------------------------------------------------+
|
| typedef bool (*FuncionLossProfitSuperate)(const double value, const double saved_value, void* ptr);
|
| typedef void (*FLossPoriftDynamic)(CLossProfit&, Dynamic_LossProfit&, Loss_Profit&, bool&, bool&, const int, int&, int&, const int, double&);
|
| #define MAX_VAL_DEFINES_CLOSS_PROFIT (DBL_MAX)
|
| #define MIN_VAL_DEFINES_CLOSE_PROFIT (-DBL_MAX)
|
|
|
| //---
|
| __forceinline bool LossProfitEmptyFuncionSup(const double value, const double saved_value, void* ptr) { return false; }
|
|
|
| //--- Tipos basicos
|
| #define LOSSPROFIT_TYPE_GMLPO 0 // Tipo base % a arriesgar
|
|
|
| //---
|
| #define LOSSPROFIT_TYPE_MDL 1 // Maxima perdida diaria
|
| #define LOSSPROFIT_TYPE_MWL 2 // Maxima perdida semanal
|
| #define LOSSPROFIT_TYPE_MML 3 // Maxima perdida mensual
|
| #define LOSSPROFIT_TYPE_ML 4 // Maxima perdida
|
| #define LOSSPROFIT_TYPE_MDDPICO 5 // Maxima perdida desde nuevo pico de la cuenta
|
|
|
| //---
|
| #define LOSSPROFIT_TYPE_MDP 6 // Maxima ganancia diaria
|
| #define LOSSPROFIT_TYPE_MWP 7 // Maxima ganancia semanal
|
| #define LOSSPROFIT_TYPE_MMP 8 // Maxima ganancia mensual
|
| #define LOSSPROFIT_TYPE_MP 9 // Maxima ganancia
|
| #define LOSSPROFIT_TYPE_MDDBAJO 10 // Maxima ganancia desde el bajo de la cuenta
|
|
|
| //--- Losses Profits
|
| #define LOSS_PROFIT_COUNT 11
|
|
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| CLossProfit Class |
|
| //+------------------------------------------------------------------+
|
| class CLossProfit : public CAccountGestor
|
| {
|
| protected:
|
| //--- General
|
| const bool m_active_hook_on_superated;
|
| const int m_type; // Type of maximum loss or profit.
|
| Loss_Profit m_lp; // Structure that will store info of this maximum loss or profit.
|
| FLossPoriftDynamic m_f_change_dynamic; // Function for dynamic risk
|
| double m_initial_calc_value; // Initial percentage
|
| bool m_empty_flag; // Empty flag
|
| double m_saved_value; // Valor base
|
| string m_name; // Nombre
|
| ENUM_LOSS_PROFIT m_type_loss_or_profit; // Tipo
|
| FuncionLossProfitSuperate m_funcion_check_sup; // Funcion custom que chekea si se ha superado
|
| const ulong m_magic_number; // Numero magico para filtrar
|
|
|
| //---
|
| void* m_ptr_to_superate; // Ptr al superar
|
|
|
| //---
|
| CRiskManagemetBase *m_risk; // Risk management to which this class is subject
|
| CHashMap<double, double> m_balance_risk_map; // HashMap for dynamic risk (percentages to exceed and new risk percentage)
|
|
|
| //--- Dynamic risk
|
| Dynamic_LossProfit m_dynamic_lp; // Structure containing the % to exceed and risks to apply
|
| bool m_activate_dynamic_risk_per_operation; // Flag indicating if dynamic risk will be applied to this "maximum loss or profit"
|
| double m_chosen_balance; // Chosen initial balance
|
| int m_index_cambio; // Change index between positives and negatives
|
| int m_size_dynamic; // Size of changes
|
| bool m_min_val_is; // Minimum value exceeded
|
| bool m_max_val_is; // Maximum value exceeded
|
| int m_pos_derecha; // Current position on right
|
| int m_pos_izquierda; // Current position on left
|
| double m_new_balance_to_overcome; // Next balance to overcome
|
|
|
| // Cache for dynamic risk parameters
|
| string m_cache_percentages_to_activate;
|
| string m_cache_risks_to_be_applied;
|
|
|
| //---
|
| virtual void OnSuperated() {}
|
|
|
|
|
| public:
|
| //--- Constructor
|
| CLossProfit(const int type, const bool im_empty, const bool act_hook, CRiskManagemetBase* _risk_pointer);
|
| ~CLossProfit() {}
|
|
|
| //--- Setters basicos
|
| void SetDynamic(string percentages_to_activate, string risks_to_be_applied, double _chosen_balance);
|
| void SetDynamic(double _chosen_balance);
|
| void SetPtrSuperated(void* ptr) { m_ptr_to_superate = ptr; }
|
|
|
| //--- Dynamic risk
|
| // Verifies and checks if the risk can be modified (only works in dynamic risk)
|
| inline void CheckAndModifyThePercentage();
|
|
|
| // Returns true if the risk is dynamic
|
| inline bool IsDynamicMode() const { return m_activate_dynamic_risk_per_operation; }
|
|
|
| //--- General getters
|
| // Returns true if the "maximum loss or profit" has been exceeded
|
| bool IsSuperated() const;
|
| __forceinline bool IsEmpty() const { return m_empty_flag; } // Esta vacio ?
|
| inline string Name() const { return m_name; } // Nombre
|
| inline ENUM_APPLIED_PERCENTAGES AppliedType() const { return m_lp.percentage_applied_to; } // Porcentage aplicado
|
| inline int Type() const { return m_type; } // Tipo
|
| inline ENUM_LOSS_PROFIT TypeLossProfit() const { return m_type_loss_or_profit; } // Tipo de loss profit
|
|
|
|
|
| //--- Functions to work with the (Percentage | Value | Profit) of the "maximum loss or profit"
|
| // Set value with calc value
|
| virtual inline bool Set() = 0;
|
| virtual bool ForzeCalcValue() const = 0;
|
|
|
| // Initial calc value (percentage or money)
|
| inline double GetInitialCalcValue() const { return m_initial_calc_value; } // Getter
|
| inline double SetInitialCalcValue() const { return (((CLossProfit*)&this).m_lp.calculation_value = m_initial_calc_value); } // Setter
|
|
|
| // Current value
|
| __forceinline double GetValue() const { return m_lp.value; } // Getter
|
| bool SetValue(double val); // Setter
|
|
|
| // Percentage (given that if the calculation mode is money, calculation_value has the money value, of course.
|
| // But modifying "m_lp.calculation_value" has no effect.
|
| inline double GetCalcValue() const { return m_lp.calculation_value; } // Getter
|
| virtual bool SetCalcValue(double val) const = 0; // Setter
|
|
|
| // Saved value
|
| double SetSavedValue() { return(m_saved_value = m_lp.value); }
|
| inline double GetSavedValue() const { return m_saved_value; }
|
|
|
| // Magic number
|
| __forceinline ulong MagicNumber() const { return m_magic_number; }
|
|
|
|
|
| //--- Static functions for risk modification (only used for dynamic risk)
|
| static void CheckPositives(CLossProfit& ptr, Dynamic_LossProfit& l_p, Loss_Profit &lossprofit, bool& min_val_is_sup, bool &empty_, const int size_cambios, int& curr_pos, int &empty_i, const int empy_a,
|
| double& new_balance_to_superate_arriba);
|
|
|
| static void CheckNegatives(CLossProfit& ptr, Dynamic_LossProfit& l_p, Loss_Profit &lossprofit, bool& min_val_is_sup, bool &empty_, const int size_cambios, int& curr_pos, int &empty_i, const int empy_a,
|
| double& new_balance_to_superate_arriba);
|
|
|
| static void CheckNegativesAndPositives(CLossProfit& ptr, Dynamic_LossProfit& l_p, Loss_Profit &lossprofit, bool& min_val_sup, bool& max_val_sup, const int size_cambios, int& curr_pos_izq,
|
| int& curr_pos_drc, const int index_change, double& new_balance_to_superate_arriba);
|
|
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Constructor |
|
| //+------------------------------------------------------------------+
|
| CLossProfit::CLossProfit(const int type, const bool im_empty, const bool act_hook, CRiskManagemetBase* _risk_pointer)
|
| :
|
| //--- Basico
|
| m_empty_flag(im_empty), m_type(type), m_initial_calc_value(0.00), m_saved_value(0.00), m_ptr_to_superate(NULL),
|
|
|
| //--- Hook
|
| m_active_hook_on_superated(act_hook),
|
|
|
|
|
| //--- Riesgo dinamico
|
| m_min_val_is(false), m_max_val_is(false), m_pos_derecha(0), m_pos_izquierda(0), m_f_change_dynamic(NULL),
|
| m_activate_dynamic_risk_per_operation(false), m_index_cambio(0), m_chosen_balance(0.00),
|
| m_new_balance_to_overcome(0.00), m_cache_percentages_to_activate(NULL), m_cache_risks_to_be_applied(NULL),
|
| m_funcion_check_sup(NULL), m_magic_number(im_empty ? NOT_MAGIC_NUMBER : _risk_pointer.MagicNumber())
|
| {
|
| //---
|
| if(m_empty_flag)
|
| return;
|
|
|
| //---
|
| this.m_risk = _risk_pointer;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| bool CLossProfit::IsSuperated(void) const
|
| {
|
| if(m_funcion_check_sup(m_lp.value, m_saved_value, m_ptr_to_superate))
|
| {
|
| if(m_active_hook_on_superated)
|
| ((CLossProfit*)&this).OnSuperated();
|
| return true;
|
| }
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Establecer el valor |
|
| //+------------------------------------------------------------------+
|
| bool CLossProfit::SetValue(double val)
|
| {
|
| //---
|
| if(m_empty_flag)
|
| {
|
| #ifdef MORE_INFO_LOSS_PROFIT_DEFINE
|
| LogWarning(StringFormat("Trying to modify value in empty object '%s'", m_name), FUNCION_ACTUAL);
|
| #endif
|
| return false;
|
| }
|
|
|
| //---
|
| if(val <= 0.0000001)
|
| {
|
| LogError(StringFormat("Invalid value %.2f for '%s': must be greater than 0.00", val, m_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| #ifdef MORE_INFO_LOSS_PROFIT_DEFINE
|
| LogInfo(StringFormat("Risk value '%s' updated: %.2f", m_name, val), FUNCION_ACTUAL);
|
| #endif
|
|
|
| //---
|
| m_lp.value = val;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Establecer el riesgo dinamico |
|
| //+------------------------------------------------------------------+
|
| void CLossProfit::SetDynamic(double _chosen_balance)
|
| {
|
| if(m_cache_percentages_to_activate == NULL || m_cache_risks_to_be_applied == NULL)
|
| {
|
| LogError("Invalid strings, first call SetDynamic(string, string, double)", FUNCION_ACTUAL);
|
| return;
|
| }
|
|
|
| //---
|
| SetDynamic(m_cache_percentages_to_activate, m_cache_risks_to_be_applied, _chosen_balance);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| void CLossProfit::SetDynamic(string percentages_to_activate, string risks_to_be_applied, double _chosen_balance)
|
| {
|
| //---
|
| if(m_empty_flag)
|
| {
|
| LogError("The risk is invalid", FUNCION_ACTUAL);
|
| this.m_activate_dynamic_risk_per_operation = false;
|
| Remover();
|
| return;
|
| }
|
|
|
| //---
|
| StrTo::CstArray(this.m_dynamic_lp.balance_to_activate_the_risk, percentages_to_activate, ',');
|
| StrTo::CstArray(this.m_dynamic_lp.risk_to_be_adjusted, risks_to_be_applied, ',');
|
|
|
| //---
|
| if(this.m_dynamic_lp.risk_to_be_adjusted.Size() < 1 || this.m_dynamic_lp.balance_to_activate_the_risk.Size() < 1)
|
| {
|
| LogCriticalError("The size of the array is less than 1", FUNCION_ACTUAL);
|
| this.m_activate_dynamic_risk_per_operation = false;
|
| return;
|
| }
|
|
|
| if(this.m_dynamic_lp.balance_to_activate_the_risk.Size() != this.m_dynamic_lp.risk_to_be_adjusted.Size())
|
| {
|
| LogCriticalError("The double arrays for the risk due to dynamic operation are not equal", FUNCION_ACTUAL);
|
| this.m_activate_dynamic_risk_per_operation = false;
|
| return;
|
| }
|
|
|
| //--- Cache values
|
| m_cache_percentages_to_activate = percentages_to_activate;
|
| m_cache_risks_to_be_applied = risks_to_be_applied;
|
|
|
| //---
|
| if(IsInfoLogEnabled())
|
| {
|
| FastLog(FUNCION_ACTUAL, INFO_TEXT, "Arrays before revision");
|
| PrintArrayAsTable(m_dynamic_lp.balance_to_activate_the_risk, "Negative percentages to modify the risk", "balance");
|
| PrintArrayAsTable(m_dynamic_lp.risk_to_be_adjusted, "Risk to be adjusted", "new risk");
|
| }
|
|
|
| //---
|
| m_balance_risk_map.Clear();
|
| int indexes_to_remove[];
|
| this.m_chosen_balance = _chosen_balance;
|
| //---
|
| for(int i = 0 ; i < ArraySize(m_dynamic_lp.balance_to_activate_the_risk) ; i++)
|
| {
|
|
|
| if(m_dynamic_lp.balance_to_activate_the_risk[i] == 0)
|
| {
|
| LogWarning("The percentage value that will be exceeded to modify the risk is 0 or less than this (it will not be taken into account)", FUNCION_ACTUAL);
|
| AddArrayNoVerification(indexes_to_remove, i, 0);
|
| continue;
|
| }
|
|
|
| if(m_balance_risk_map.ContainsKey(m_dynamic_lp.balance_to_activate_the_risk[i]) == false)
|
| m_balance_risk_map.Add(m_dynamic_lp.balance_to_activate_the_risk[i], m_dynamic_lp.risk_to_be_adjusted[i]);
|
| else
|
| AddArrayNoVerification(indexes_to_remove, i, 0);
|
| }
|
|
|
| //---
|
| RemoveMultipleIndexes(m_dynamic_lp.balance_to_activate_the_risk, indexes_to_remove, 0);
|
| ArraySort(m_dynamic_lp.balance_to_activate_the_risk);
|
| ArrayResize(m_dynamic_lp.risk_to_be_adjusted, ArraySize(m_dynamic_lp.balance_to_activate_the_risk));
|
|
|
| //---
|
| this.m_size_dynamic = ArraySize(m_dynamic_lp.balance_to_activate_the_risk);
|
|
|
| //---
|
| const bool hay_positivos = HayPositivosArray(m_dynamic_lp.balance_to_activate_the_risk);
|
| const bool hay_negativos = HayNegativosArray(m_dynamic_lp.balance_to_activate_the_risk);
|
| bool c = false;
|
|
|
| //---
|
| for(int i = 0 ; i < this.m_size_dynamic; i++)
|
| {
|
| double value;
|
| m_balance_risk_map.TryGetValue(this.m_dynamic_lp.balance_to_activate_the_risk[i], value);
|
|
|
| m_dynamic_lp.risk_to_be_adjusted[i] = value;
|
| m_dynamic_lp.balance_to_activate_the_risk[i] = (this.m_chosen_balance + (this.m_chosen_balance * (m_dynamic_lp.balance_to_activate_the_risk[i] / 100.0)));
|
|
|
| if(i < ArraySize(m_dynamic_lp.balance_to_activate_the_risk) - 1 && hay_negativos && hay_positivos && !c)
|
| {
|
| if(m_dynamic_lp.balance_to_activate_the_risk[i] > 0 && m_dynamic_lp.balance_to_activate_the_risk[i + 1] < 0)
|
| {
|
| m_index_cambio = i + 1; //WARNING: left position is used by default for the simple case only negatives or positives.
|
| }
|
| }
|
| }
|
|
|
| //---
|
| this.m_min_val_is = false;
|
| this.m_max_val_is = false;
|
|
|
| //---
|
| if(hay_negativos && !hay_positivos)
|
| {
|
| m_pos_izquierda = this.m_size_dynamic - 1;
|
| m_new_balance_to_overcome = MAX_VAL_DEFINES_CLOSS_PROFIT;
|
| m_f_change_dynamic = CLossProfit::CheckNegatives;
|
| }
|
| else
|
| if(hay_positivos && !hay_negativos)
|
| {
|
| m_pos_izquierda = 0;
|
| m_new_balance_to_overcome = MIN_VAL_DEFINES_CLOSE_PROFIT;
|
| m_f_change_dynamic = CLossProfit::CheckPositives;
|
| }
|
| else
|
| {
|
| m_pos_izquierda = m_index_cambio + 1;
|
| m_pos_derecha = m_index_cambio;
|
| m_f_change_dynamic = CLossProfit::CheckNegativesAndPositives;
|
| }
|
|
|
| //---
|
| this.m_activate_dynamic_risk_per_operation = true;
|
| if(IsInfoLogEnabled())
|
| {
|
| FastLog(FUNCION_ACTUAL, INFO_TEXT, "Arrays ready");
|
| PrintArrayAsTable(m_dynamic_lp.balance_to_activate_the_risk, "Negative percentages to modify the risk", "balance");
|
| PrintArrayAsTable(m_dynamic_lp.risk_to_be_adjusted, "Risk to be adjusted", "new risk");
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Checks and modifies the percentage |
|
| //+------------------------------------------------------------------+
|
| inline void CLossProfit::CheckAndModifyThePercentage(void)
|
| {
|
| if(!m_activate_dynamic_risk_per_operation)
|
| {
|
| LogError(StringFormat("Risk %s is not allowed to use dynamic risk", m_name), FUNCION_ACTUAL);
|
| Remover();
|
| return;
|
| }
|
| this.m_f_change_dynamic(this, m_dynamic_lp, m_lp, m_min_val_is, m_max_val_is, m_size_dynamic, m_pos_izquierda, m_pos_derecha, m_index_cambio, m_new_balance_to_overcome);
|
| // Print(m_lp.calculation_value);
|
| }
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| Funciones estaticas para chekear y modficar el porcentaje |
|
| //+------------------------------------------------------------------+
|
| static void CLossProfit::CheckPositives(CLossProfit& ptr, Dynamic_LossProfit& l_p, Loss_Profit &lossprofit, bool& min_val_is_sup, bool &empty_, const int size_cambios, int& curr_pos, int &empty_i, const int empy_a,
|
| double& new_balance_to_superate_arriba)
|
| {
|
| //---
|
| const double account_equity = AccountInfoDouble(ACCOUNT_EQUITY);
|
|
|
| //---
|
| if(!min_val_is_sup && account_equity > l_p.balance_to_activate_the_risk[curr_pos]) //toca aumentar riesgo o parar
|
| {
|
| bool normal = false;
|
| const int last = size_cambios - 1;
|
|
|
| while(curr_pos < last)
|
| {
|
| if(account_equity > l_p.balance_to_activate_the_risk[curr_pos++] && l_p.balance_to_activate_the_risk[curr_pos] > account_equity)
|
| {
|
| normal = true;
|
| break;
|
| }
|
| }
|
|
|
| if(normal)
|
| {
|
| new_balance_to_superate_arriba = l_p.balance_to_activate_the_risk[curr_pos - 1];
|
| lossprofit.calculation_value = l_p.risk_to_be_adjusted[curr_pos - 1];
|
| }
|
| else
|
| if(account_equity > l_p.balance_to_activate_the_risk[curr_pos])
|
| {
|
| //verificamos si es mayor, si lo es entonces asiganmos como el maixmo, (hacemos esto por que si size_cambio es 1 no entratra al while, si es mayor a 2 esta verificaion no tiene sentido )
|
| //pero para no estar haciendo otro else if, enotnce shacmeos esto
|
| lossprofit.calculation_value = l_p.risk_to_be_adjusted[curr_pos]; //llegamos al maximo asignamos el maximo posible
|
| new_balance_to_superate_arriba = curr_pos > 0 ? l_p.balance_to_activate_the_risk[curr_pos - 1] : l_p.balance_to_activate_the_risk[curr_pos];
|
| min_val_is_sup = true; //llegamos al maximo
|
| }
|
| }
|
|
|
| //---
|
| if(account_equity < new_balance_to_superate_arriba) //toca disminir riesgo o parar
|
| {
|
| bool normal = false;
|
|
|
| while(curr_pos > 0)
|
| {
|
| curr_pos--;
|
| if(l_p.balance_to_activate_the_risk[curr_pos] < account_equity)
|
| {
|
| normal = true;
|
| break;
|
| }
|
| }
|
|
|
| if(normal)
|
| {
|
| lossprofit.calculation_value = l_p.risk_to_be_adjusted[curr_pos];
|
| new_balance_to_superate_arriba = l_p.balance_to_activate_the_risk[curr_pos];
|
| curr_pos++;
|
| }
|
| else
|
| {
|
| new_balance_to_superate_arriba = MIN_VAL_DEFINES_CLOSE_PROFIT;
|
| // En este caso si o si es porcentaje
|
| lossprofit.calculation_value = ptr.GetInitialCalcValue(); //nos pasamos del miinimo entonces aisgnamos el porcentake inicial
|
| }
|
| min_val_is_sup = false; //Reseteamos, ahora si es pobible aumentar el riesgo
|
| }
|
| }
|
|
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| static void CLossProfit::CheckNegatives(CLossProfit& ptr, Dynamic_LossProfit& l_p, Loss_Profit &lossprofit, bool& min_val_is_sup, bool &empty_, const int size_cambios, int& curr_pos, int &empty_i,
|
| const int empy_a,
|
| double& new_balance_to_superate_arriba)
|
| {
|
| //---
|
| const double account_equity = AccountInfoDouble(ACCOUNT_EQUITY);
|
|
|
| //---
|
| if(!min_val_is_sup && account_equity < l_p.balance_to_activate_the_risk[curr_pos]) //toca aumentar riesgo o parar
|
| {
|
| bool normal = false;
|
|
|
| while(curr_pos > 0)
|
| {
|
| curr_pos--;
|
| if(account_equity > l_p.balance_to_activate_the_risk[curr_pos])
|
| {
|
| normal = true;
|
| break;
|
| }
|
| }
|
|
|
| if(normal)
|
| empty_i = curr_pos + 1; //curpos apunta abajo, y empty a arriab
|
| else
|
| {
|
| empty_i = curr_pos; //ambos abajo pero eso cambia
|
| min_val_is_sup = true; //llegamos al minimo
|
| }
|
|
|
| //---
|
| lossprofit.calculation_value = l_p.risk_to_be_adjusted[empty_i];
|
| new_balance_to_superate_arriba = l_p.balance_to_activate_the_risk[empty_i]; //arriba
|
| }
|
|
|
| //---
|
| if(account_equity > new_balance_to_superate_arriba) //toca disminir riesgo o parar
|
| {
|
| const int last = size_cambios - 1;
|
| bool normal = false;
|
|
|
| while(curr_pos < last)
|
| {
|
| if(account_equity < l_p.balance_to_activate_the_risk[curr_pos++] && account_equity < l_p.balance_to_activate_the_risk[curr_pos])
|
| {
|
| normal = true;
|
| break;
|
| }
|
| }
|
|
|
| if(normal)
|
| {
|
| lossprofit.calculation_value = l_p.risk_to_be_adjusted[curr_pos]; //usa el riesgo de aqui
|
| empty_i = curr_pos;
|
| new_balance_to_superate_arriba = l_p.balance_to_activate_the_risk[empty_i];
|
| curr_pos--; //apunta abajo
|
| }
|
| else //nos pasmaos entonces, riesgo inicial
|
| {
|
| lossprofit.calculation_value = ptr.GetInitialCalcValue(); // En este caso si o si es porcentaje
|
| new_balance_to_superate_arriba = MAX_VAL_DEFINES_CLOSS_PROFIT;
|
| }
|
| min_val_is_sup = false; //llegamos al maximo
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| static void CLossProfit::CheckNegativesAndPositives(CLossProfit& ptr, Dynamic_LossProfit& l_p, Loss_Profit &lossprofit, bool& min_val_sup,
|
| bool& max_val_sup, const int size_cambios, int& curr_pos_izq, int& curr_pos_drc, const int index_change, double& new_balance_to_superate_arriba)
|
| {
|
| //---
|
| const double account_equity = AccountInfoDouble(ACCOUNT_EQUITY);
|
| // PrintFormat("%d - %d - cambio en: %d",curr_pos_izq,curr_pos_drc, index_change);
|
|
|
| //---
|
| if(!min_val_sup && account_equity < l_p.balance_to_activate_the_risk[curr_pos_drc]) //toca aumentar riesgo o parar
|
| {
|
| if(max_val_sup)
|
| curr_pos_izq++; //size + 1, y luego en while ya se ve la direfencia de 1
|
|
|
| //---
|
| bool normal = false;
|
| bool mid = false;
|
|
|
| //---
|
| while(curr_pos_drc > 0)
|
| {
|
| curr_pos_izq--;
|
| curr_pos_drc--;
|
|
|
| if(account_equity > l_p.balance_to_activate_the_risk[curr_pos_drc])
|
| {
|
| mid = curr_pos_drc == index_change;
|
| normal = true;
|
| break;
|
| }
|
| }
|
|
|
| //---
|
| if(mid)
|
| lossprofit.calculation_value = ptr.GetInitialCalcValue(); // En este caso si o si es porcentaje
|
| else
|
| if(normal)
|
| {
|
| const int sum = curr_pos_drc < index_change; //si es
|
| lossprofit.calculation_value = l_p.risk_to_be_adjusted[curr_pos_drc + sum]; //+0 si estamos en linea psoitov y +1 si en negacitva (dado que en positiva los porecntjases son <-)
|
| }
|
| else
|
| {
|
| lossprofit.calculation_value = l_p.risk_to_be_adjusted[curr_pos_drc];
|
| min_val_sup = true; //llegamos al minimo
|
| curr_pos_izq = curr_pos_drc;
|
| }
|
|
|
| max_val_sup = false;
|
| }
|
|
|
| //---
|
| if(!max_val_sup && account_equity > l_p.balance_to_activate_the_risk[curr_pos_izq]) //toca disminir riesgo o parar
|
| {
|
| if(min_val_sup)
|
| {
|
| curr_pos_drc--; //-1
|
| }
|
|
|
| const int last = size_cambios - 1;
|
| bool normal = false;
|
| bool mid = false;
|
|
|
| while(curr_pos_izq < last)
|
| {
|
| curr_pos_drc++;
|
| curr_pos_izq++;
|
|
|
| if(l_p.balance_to_activate_the_risk[curr_pos_izq] > account_equity && account_equity > l_p.balance_to_activate_the_risk[curr_pos_drc])
|
| {
|
| normal = true;
|
| mid = curr_pos_drc == index_change;
|
| break;
|
| }
|
| }
|
|
|
| if(mid)
|
| lossprofit.calculation_value = ptr.GetInitialCalcValue(); // En este caso si o si es porcentaje
|
| else
|
| if(normal)
|
| {
|
| const int sum = curr_pos_izq < index_change; //si es
|
| lossprofit.calculation_value = l_p.risk_to_be_adjusted[curr_pos_izq + sum];
|
| }
|
| else //nos pasmaos entonces, riesgo inicial
|
| {
|
| lossprofit.calculation_value = l_p.risk_to_be_adjusted[curr_pos_izq]; //maximo
|
| max_val_sup = true; //llegamos al maximo
|
| curr_pos_drc = curr_pos_izq;
|
| }
|
|
|
| min_val_sup = false;
|
| }
|
|
|
| //---
|
| //PrintFormat("%d - %d - cambio en: %d",curr_pos_izq,curr_pos_drc, index_change);
|
| }
|
| //+------------------------------------------------------------------+
|
|
|
|
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| template <typename TPadre>
|
| class CLossProfitPercentage : public TPadre
|
| {
|
| public:
|
| //---
|
| CLossProfitPercentage(const int type, const bool im_empty, const bool act_hook, CRiskManagemetBase* &_risk_pointer)
|
| : TPadre(type, im_empty, act_hook, _risk_pointer) {}
|
| ~CLossProfitPercentage(void) {}
|
| //---
|
| bool ForzeCalcValue() const override;
|
| bool SetCalcValue(double val) const override;
|
| bool Set() override;
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| template <typename TPadre>
|
| bool CLossProfitPercentage::ForzeCalcValue() const
|
| {
|
| if(m_empty_flag || m_type == LOSSPROFIT_TYPE_GMLPO) // Si esta vacio o es gmplo retornamos
|
| return false;
|
| //---
|
| const double dff = GetSavedValue() - m_lp.value;
|
| CLossProfitPercentage<TPadre>* este = (CLossProfitPercentage<TPadre>*)&this;
|
| este.m_lp.value = m_risk.GetValorWithApplied(m_lp.calculation_value, m_type, m_lp.percentage_applied_to) - dff;
|
| este.m_saved_value = este.m_lp.value;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| template <typename TPadre>
|
| inline bool CLossProfitPercentage::Set()
|
| {
|
| if(m_empty_flag)
|
| return false;
|
| m_lp.value = m_risk.GetValorWithApplied(m_lp.calculation_value, m_type, m_lp.percentage_applied_to);
|
| #ifdef MORE_INFO_LOSS_PROFIT_DEFINE
|
| LogCaution(StringFormat("New value of %s: %.2f", this.m_name, m_lp.value), FUNCION_ACTUAL);
|
| #endif
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| template <typename TPadre>
|
| bool CLossProfitPercentage::SetCalcValue(double val) const
|
| {
|
| //---
|
| if(m_empty_flag)
|
| {
|
| #ifdef MORE_INFO_LOSS_PROFIT_DEFINE
|
| LogWarning(StringFormat("Trying to modify percentage on empty object '%s'", m_name), FUNCION_ACTUAL);
|
| #endif
|
| return false;
|
| }
|
|
|
| //---
|
| if(val <= 0.00)
|
| {
|
| LogError(StringFormat("Invalid percentage %.2f%% for '%s': must be greater than 0", val, m_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| if(val >= 100.00)
|
| {
|
| LogWarning(StringFormat("Percentage %.2f for '%s' exceeds 100%%, limiting to 100%%", val, m_name), FUNCION_ACTUAL);
|
| val = 100.00;
|
| }
|
|
|
| //---
|
| LogInfo(StringFormat("Risk percentage '%s' updated: %.2f%%", m_name, val), FUNCION_ACTUAL);
|
|
|
| //---
|
| ((CLossProfitPercentage<TPadre>*)&this).m_lp.calculation_value = val;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| template <typename TPadre>
|
| class CLossProfitMoney : public TPadre
|
| {
|
| public:
|
| //---
|
| CLossProfitMoney(const int type, const bool im_empty, const bool act_hook, CRiskManagemetBase* &_risk_pointer)
|
| : TPadre(type, im_empty, act_hook, _risk_pointer) {}
|
| ~CLossProfitMoney(void) {}
|
|
|
| //---
|
| bool SetCalcValue(double val) const override;
|
| bool Set() override;
|
| bool ForzeCalcValue() const override;
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| template <typename TPadre>
|
| bool CLossProfitMoney::ForzeCalcValue() const
|
| {
|
| if(m_empty_flag || m_type == LOSSPROFIT_TYPE_GMLPO) // Si esta vacio o es gmplo retornamos
|
| return false;
|
| //---
|
| const double dff = GetSavedValue() - m_lp.calculation_value;
|
| CLossProfitMoney<TPadre>* este = (CLossProfitMoney<TPadre>*)&this;
|
| este.m_lp.value = m_lp.calculation_value - dff;
|
| este.m_saved_value = este.m_lp.value;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| template <typename TPadre>
|
| inline bool CLossProfitMoney::Set()
|
| {
|
| if(m_empty_flag)
|
| return false;
|
| m_lp.value = m_lp.calculation_value;
|
| #ifdef MORE_INFO_LOSS_PROFIT_DEFINE
|
| LogCaution(StringFormat("New value of %s: %.2f", this.m_name, m_lp.value), FUNCION_ACTUAL);
|
| #endif
|
| return true;
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TPadre>
|
| bool CLossProfitMoney::SetCalcValue(double val) const
|
| {
|
| //---
|
| if(m_empty_flag)
|
| {
|
| #ifdef MORE_INFO_LOSS_PROFIT_DEFINE
|
| LogWarning(StringFormat("Trying to modify base money on empty object '%s'", m_name), FUNCION_ACTUAL);
|
| #endif
|
| return false;
|
| }
|
|
|
| //---
|
| if(val <= 0.00)
|
| {
|
| LogError(StringFormat("Invalid new base money %.2f for '%s': must be greater than 0.00", val, m_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| LogInfo(StringFormat("Risk base money '%s' updated: %.2f", m_name, val), FUNCION_ACTUAL);
|
|
|
| //---
|
| ((CLossProfitMoney<TPadre>*)&this).m_lp.calculation_value = val;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| #endif // MQLARTICLES_RM_LOSSPROFIT_BASE_MQH
|