forked from antekov/Adwizard
//+------------------------------------------------------------------+
| |
//| VirtualRiskManager.mqh |
| |
//| Copyright 2022-2025, Yuriy Bykov |
| |
//| https://www.mql5.com/ru/users/antekov |
| |
//+------------------------------------------------------------------+
| |
#property copyright "Copyright 2022-2025, Yuriy Bykov"
| |
#property link "https://www.mql5.com/ru/users/antekov"
| |
#property version "1.06"
| |
| |
#include "../Database/Storage.mqh"
| |
| |
// Возможные состояния риск-менеджера
| |
enum ENUM_RM_STATE {
| |
RM_STATE_OK, // Лимиты не превышены
| |
RM_STATE_DAILY_LOSS, // Превышен дневной лимит
| |
RM_STATE_RESTORE, // Восстановление после дневного лимита
| |
RM_STATE_OVERALL_LOSS, // Превышен общий лимит
| |
RM_STATE_OVERALL_PROFIT // Достигнута общая прибыль
| |
};
| |
| |
// Возможные способы расчёта дневных лимитов
| |
enum ENUM_RM_CALC_DAILY_LOSS {
| |
RM_CALC_DAILY_LOSS_MONEY_BB, // [$] to Daily Level
| |
RM_CALC_DAILY_LOSS_PERCENT_BB, // [%] from Base Balance to Daily Level
| |
RM_CALC_DAILY_LOSS_PERCENT_DL // [%] from/to Daily Level
| |
};
| |
| |
// Возможные способы расчёта общих лимитов
| |
enum ENUM_RM_CALC_OVERALL_LOSS {
| |
RM_CALC_OVERALL_LOSS_MONEY_BB, // [$] to Base Balance
| |
RM_CALC_OVERALL_LOSS_MONEY_HW_BAL, // [$] to HW Balance
| |
RM_CALC_OVERALL_LOSS_MONEY_HW_EQ_BAL, // [$] to HW Equity or Balance
| |
RM_CALC_OVERALL_LOSS_PERCENT_BB, // [%] from/to Base Balance
| |
RM_CALC_OVERALL_LOSS_PERCENT_HW_BAL, // [%] from/to HW Balance
| |
RM_CALC_OVERALL_LOSS_PERCENT_HW_EQ_BAL // [%] from/to HW Equity or Balance
| |
};
| |
| |
// Возможные способы расчёта общей прибыли
| |
enum ENUM_RM_CALC_OVERALL_PROFIT {
| |
RM_CALC_OVERALL_PROFIT_MONEY_BB, // [$] to Base Balance
| |
RM_CALC_OVERALL_PROFIT_PERCENT_BB, // [%] from/to Base Balance
| |
};
| |
| |
//+------------------------------------------------------------------+
| |
//| Класс управления риском (риск-менеждер) |
| |
//+------------------------------------------------------------------+
| |
class CVirtualRiskManager : public CFactorable {
| |
protected:
| |
// Основные параметры конструктора
| |
//bool m_isActive; // Риск менеджер активен?
| |
| |
double m_baseBalance; // Базовый баланс
| |
| |
ENUM_RM_CALC_DAILY_LOSS m_calcDailyLossLimit; // Способ расчёта максимального дневного убытка
| |
double m_maxDailyLossLimit; // Параметр расчёта максимального дневного убытка
| |
double m_closeDailyPart; // Значение пороговой части дневного убытка
| |
| |
ENUM_RM_CALC_OVERALL_LOSS m_calcOverallLossLimit; // Способ расчёта максимального общего убытка
| |
double m_maxOverallLossLimit; // Параметр расчёта максимального общего убытка
| |
double m_closeOverallPart; // Значение пороговой части общего убытка
| |
| |
ENUM_RM_CALC_OVERALL_PROFIT m_calcOverallProfitLimit; // Способ расчёта максимальной общей прибыли
| |
double m_maxOverallProfitLimit; // Параметр расчёта максимальной общей прибыли
| |
datetime m_maxOverallProfitDate; // Предельное время для достижения общей прибыли
| |
| |
double m_maxRestoreTime; // Время ожидания лучшего входа на просадке
| |
double m_lastVirtualProfitFactor; // Множитель начальной лучшей просадки
| |
| |
| |
// Текущее состояние
| |
ENUM_RM_STATE m_state; // Состояние
| |
double m_lastVirtualProfit; // Прибыль открытых виртуальных позиций на момент лимита убытка
| |
datetime m_startRestoreTime; // Время начала восстановления размеров открытых позиций
| |
datetime m_startTime;
| |
| |
// Обновляемые значения
| |
double m_balance; // Текущий баланс
| |
double m_equity; // Текущие средства
| |
double m_profit; // Текущая прибыль
| |
double m_dailyProfit; // Дневная прибыль
| |
double m_overallProfit; // Общая прибыль
| |
double m_baseDailyBalance; // Дневной базовый баланс
| |
double m_baseDailyEquity; // Дневные базовые средства
| |
double m_baseDailyLevel; // Дневной базовый уровень
| |
double m_baseHWBalance; // High Watermark баланса
| |
double m_baseHWEquityBalance; // High Watermark средств или баланса
| |
double m_virtualProfit; // Прибыль открытых виртуальных позиций
| |
| |
// Управление размером открытых позиций
| |
double m_baseDepoPart; // Используемая часть общего баланса (исходная)
| |
double m_dailyDepoPart; // Множитель используемой части общего баланса по дневному убытку
| |
double m_overallDepoPart; // Множитель используемой части общего баланса по общему убытку
| |
| |
string m_text;
| |
| |
// Защищённые методы
| |
double DailyLoss(); // Максимальный дневной убыток
| |
double OverallLoss(); // Максимальный общий убыток
| |
double OverallProfit(); // Максимальная прибыль
| |
| |
void UpdateProfit(); // Обновление текущих значений прибыли
| |
void UpdateBaseLevels(); // Обновление дневных базовых уровней
| |
| |
void CheckLimits(); // Проверка превышения допустимых убытков
| |
bool CheckDailyLossLimit(); // Проверка превышения допустимого дневного убытка
| |
bool CheckOverallLossLimit(); // Проверка превышения допустимого общего убытка
| |
bool CheckOverallProfitLimit(); // Проверка достижения заданной прибыли
| |
| |
void CheckRestore(); // Проверка необходимости восстановления размеров открытых позиций
| |
bool CheckDailyRestore(); // Проверка необходимости восстановления дневного множителя
| |
bool CheckOverallRestore(); // Проверка необходимости восстановления общего множителя
| |
| |
double VirtualProfit(); // Определение прибыли открытых виртуальных позиций
| |
double RestoreVirtualProfit(); // Определение прибыли открытых виртуальных позиций для восстановления
| |
| |
void SetDepoPart(); // Установка значения используемой части общего баланса
| |
| |
CVirtualRiskManager(string p_params); // Конструктор
| |
| |
public:
| |
STATIC_CONSTRUCTOR(CVirtualRiskManager);
| |
virtual void Tick(); // Обработка тика в риск-менеджере
| |
virtual string Text(); // Вывод информации
| |
| |
virtual bool Save(); // Сохранение состояния
| |
virtual bool Load(); // Загрузка состояния
| |
| |
virtual string operator~() override; // Преобразование объекта в строку
| |
};
| |
| |
REGISTER_FACTORABLE_CLASS(CVirtualRiskManager);
| |
| |
//+------------------------------------------------------------------+
| |
//| Конструктор |
| |
//+------------------------------------------------------------------+
| |
CVirtualRiskManager::CVirtualRiskManager(string p_params) {
| |
// Запоминаем строку инициализации
| |
m_params = p_params;
| |
| |
// Читаем строку инициализации и устанавливаем значения свойств
| |
m_isActive = (bool) ReadLong(p_params);
| |
m_baseBalance = ReadDouble(p_params);
| |
m_calcDailyLossLimit = (ENUM_RM_CALC_DAILY_LOSS) ReadLong(p_params);
| |
m_maxDailyLossLimit = ReadDouble(p_params);
| |
m_closeDailyPart = ReadDouble(p_params);
| |
m_calcOverallLossLimit = (ENUM_RM_CALC_OVERALL_LOSS) ReadLong(p_params);
| |
m_maxOverallLossLimit = ReadDouble(p_params);
| |
m_closeOverallPart = ReadDouble(p_params);
| |
m_calcOverallProfitLimit = (ENUM_RM_CALC_OVERALL_PROFIT) ReadLong(p_params);
| |
m_maxOverallProfitLimit = ReadDouble(p_params);
| |
m_maxOverallProfitDate = (datetime) ReadLong(p_params);
| |
m_maxRestoreTime = ReadDouble(p_params);
| |
m_lastVirtualProfitFactor = ReadDouble(p_params);
| |
| |
| |
// Устанавливаем состояние: Лимиты не превышены
| |
m_state = RM_STATE_OK;
| |
m_dailyDepoPart = 1;
| |
m_overallDepoPart = 1;
| |
m_lastVirtualProfit = 0;
| |
m_startRestoreTime = 0;
| |
| |
// Запоминаем долю баланса счёта, выделенного на торговлю
| |
m_baseDepoPart = CMoney::DepoPart();
| |
| |
// Обновляем базовые дневные уровни
| |
UpdateBaseLevels();
| |
| |
// Корректируем базовый баланс, если он не задан
| |
if(m_baseBalance == 0) {
| |
m_baseBalance = m_balance;
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Обработка тика в риск-менеджере |
| |
//+------------------------------------------------------------------+
| |
void CVirtualRiskManager::Tick() {
| |
// Если риск-менеджер неактивен, то выходим
| |
if(!m_isActive) {
| |
return;
| |
}
| |
| |
// Обновляем текущие значения прибыли
| |
UpdateProfit();
| |
| |
// Если наступил новый дневной период, то обновляем базовые дневные уровни
| |
if(IsNewBar(Symbol(), PERIOD_D1)) {
| |
UpdateBaseLevels();
| |
}
| |
| |
CheckRestore();
| |
| |
// Проверяем превышение пределов убытка
| |
CheckLimits();
| |
}
| |
| |
string CVirtualRiskManager::Text() {
| |
string s = "=== Risk Manager ===\n";
| |
| |
s += m_text + "\n";
| |
| |
return s;
| |
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Сохранение состояния |
| |
//+------------------------------------------------------------------+
| |
bool CVirtualRiskManager::Save() {
| |
CStorage::Set("CVirtualRiskManager::m_state", m_state);
| |
CStorage::Set("CVirtualRiskManager::m_lastVirtualProfit", m_lastVirtualProfit);
| |
CStorage::Set("CVirtualRiskManager::m_startRestoreTime", m_startRestoreTime);
| |
CStorage::Set("CVirtualRiskManager::m_startTime", m_startTime);
| |
CStorage::Set("CVirtualRiskManager::m_dailyDepoPart", m_dailyDepoPart);
| |
CStorage::Set("CVirtualRiskManager::m_overallDepoPart", m_overallDepoPart);
| |
| |
return true;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Загрузка состояния |
| |
//+------------------------------------------------------------------+
| |
bool CVirtualRiskManager::Load() {
| |
CStorage::Get("CVirtualRiskManager::m_state", m_state);
| |
CStorage::Get("CVirtualRiskManager::m_lastVirtualProfit", m_lastVirtualProfit);
| |
CStorage::Get("CVirtualRiskManager::m_startRestoreTime", m_startRestoreTime);
| |
CStorage::Get("CVirtualRiskManager::m_startTime", m_startTime);
| |
CStorage::Get("CVirtualRiskManager::m_dailyDepoPart", m_dailyDepoPart);
| |
CStorage::Get("CVirtualRiskManager::m_overallDepoPart", m_overallDepoPart);
| |
| |
//m_state = (ENUM_RM_STATE) FileReadNumber(f);
| |
//m_lastVirtualProfit = FileReadNumber(f);
| |
//m_startRestoreTime = FileReadDatetime(f);
| |
//m_startTime = FileReadDatetime(f);
| |
//m_dailyDepoPart = FileReadNumber(f);
| |
//m_overallDepoPart = FileReadNumber(f);
| |
| |
return true;
| |
}
| |
| |
| |
//+------------------------------------------------------------------+
| |
//| Проверка необходимости восстановления размеров открытых позиций |
| |
//+------------------------------------------------------------------+
| |
void CVirtualRiskManager::CheckRestore() {
| |
// Если нужно восстанавливать состояние до нормального, то
| |
if(m_state == RM_STATE_RESTORE) {
| |
// Проверяем возможность восстановить до нормального множитель дневного убытка
| |
bool dailyRes = CheckDailyRestore();
| |
| |
// Проверяем возможность восстановить до нормального множитель общего убытка
| |
bool overallRes = CheckOverallRestore();
| |
| |
// Если хотя бы один из них восстановился, то
| |
if(dailyRes || overallRes) {
| |
PrintFormat(__FUNCTION__" | VirtualProfit = %.2f | Profit = %.2f | Daily Profit = %.2f",
| |
m_virtualProfit, m_profit, m_dailyProfit);
| |
PrintFormat(__FUNCTION__" | RESTORE: depoPart = %.2f = %.2f * %.2f * %.2f",
| |
m_baseDepoPart * m_dailyDepoPart * m_overallDepoPart,
| |
m_baseDepoPart, m_dailyDepoPart, m_overallDepoPart);
| |
| |
// Устанавливаем значение используемой части общего баланса
| |
SetDepoPart();
| |
| |
// Оповещаем получатель об изменениях
| |
CVirtualReceiver::Instance().Changed();
| |
| |
// Если оба множителя восстановлены до нормальных, то
| |
if(dailyRes && overallRes) {
| |
// Устанавливаем нормальное состояние
| |
m_state = RM_STATE_OK;
| |
}
| |
}
| |
//else {
| |
// if(IsNewBar(Symbol(), PERIOD_H1)) {
| |
// PrintFormat(__FUNCTION__" | VirtualProfit = %.2f | Profit = %.2f | Daily Profit = %.2f",
| |
// m_virtualProfit, m_profit, m_dailyProfit);
| |
// PrintFormat(__FUNCTION__" | WAIT RESTORE: depoPart = %.2f = %.2f * %.2f * %.2f",
| |
// m_baseDepoPart * m_dailyDepoPart * m_overallDepoPart,
| |
// m_baseDepoPart, m_dailyDepoPart, m_overallDepoPart);
| |
// }
| |
//}
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Проверка необходимости восстановления дневного множителя |
| |
//+------------------------------------------------------------------+
| |
bool CVirtualRiskManager::CheckDailyRestore() {
| |
// Если текущая виртуальная прибыль меньше желаемой для восстановления, то
| |
if(m_virtualProfit <= RestoreVirtualProfit()) {
| |
// Восстанавливаем множитель дневного убытка
| |
m_dailyDepoPart = 1.0;
| |
return true;
| |
}
| |
| |
return false;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Проверка необходимости восстановления общего множителя |
| |
//+------------------------------------------------------------------+
| |
bool CVirtualRiskManager::CheckOverallRestore() {
| |
// Если текущая виртуальная прибыль меньше желаемой для восстановления, то
| |
if(m_virtualProfit <= RestoreVirtualProfit()) {
| |
// Восстанавливаем множитель общего убытка
| |
m_overallDepoPart = 1.0;
| |
return true;
| |
}
| |
| |
return false;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Максимальный дневной убыток |
| |
//+------------------------------------------------------------------+
| |
double CVirtualRiskManager::DailyLoss() {
| |
if(m_calcDailyLossLimit == RM_CALC_DAILY_LOSS_PERCENT_BB) {
| |
// Для заданного процента от базового баланса вычисляем его
| |
return m_baseBalance * m_maxDailyLossLimit / 100;
| |
} else if(m_calcDailyLossLimit == RM_CALC_DAILY_LOSS_PERCENT_DL) {
| |
// Для заданного процента от дневного уровня вычисляем его
| |
return m_baseDailyLevel * m_maxDailyLossLimit / 100;
| |
} else {
| |
// Для фиксированного значения просто возвращаем его
| |
return m_maxDailyLossLimit;
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Максимальный общий убыток |
| |
//+------------------------------------------------------------------+
| |
double CVirtualRiskManager::OverallLoss() {
| |
if(m_calcOverallLossLimit == RM_CALC_OVERALL_LOSS_PERCENT_BB) {
| |
// Для заданного процента от базового баланса вычисляем его
| |
return m_baseBalance * m_maxOverallLossLimit / 100;
| |
} else if(m_calcOverallLossLimit == RM_CALC_OVERALL_LOSS_PERCENT_HW_BAL) {
| |
// Для заданного процента от дневного уровня вычисляем его
| |
return m_baseHWBalance * m_maxOverallLossLimit / 100;
| |
} else if(m_calcOverallLossLimit == RM_CALC_OVERALL_LOSS_PERCENT_HW_EQ_BAL) {
| |
// Для заданного процента от дневного уровня вычисляем его
| |
return m_baseHWEquityBalance * m_maxOverallLossLimit / 100;
| |
} else {
| |
// Для фиксированного значения просто возвращаем его
| |
// RM_CALC_OVERALL_LOSS_MONEY_BB || RM_CALC_OVERALL_LOSS_MONEY_HW_BAL
| |
return m_maxOverallLossLimit;
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Максимальный общая прибыль |
| |
//+------------------------------------------------------------------+
| |
double CVirtualRiskManager::OverallProfit() {
| |
// Текущее время
| |
datetime tc = TimeCurrent();
| |
| |
// Если текущее время больше заданного максимально допустимого, то
| |
if(m_maxOverallProfitDate && tc > m_maxOverallProfitDate) {
| |
// Возвращаем значение, гарантирующее закрытие позиций
| |
return m_overallProfit;
| |
} else if(m_calcOverallProfitLimit == RM_CALC_OVERALL_PROFIT_PERCENT_BB) {
| |
// Для заданного процента от базового баланса вычисляем его
| |
return m_baseBalance * m_maxOverallProfitLimit / 100;
| |
} else {
| |
// Для фиксированного значения просто возвращаем его
| |
// RM_CALC_OVERALL_PROFIT_MONEY_BB
| |
return m_maxOverallProfitLimit;
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Обновление текущих значений прибыли |
| |
//+------------------------------------------------------------------+
| |
void CVirtualRiskManager::UpdateProfit() {
| |
// Текущие средства
| |
m_equity = AccountInfoDouble(ACCOUNT_EQUITY);
| |
| |
// Текущий баланс
| |
m_balance = AccountInfoDouble(ACCOUNT_BALANCE);
| |
| |
// Наивысший баланс (High Watermark)
| |
m_baseHWBalance = MathMax(m_balance, m_baseHWBalance);
| |
| |
// Наивысший баланс или средства (High Watermark)
| |
m_baseHWEquityBalance = MathMax(m_equity, MathMax(m_balance, m_baseHWEquityBalance));
| |
| |
// Текущая прибыль
| |
m_profit = m_equity - m_balance;
| |
| |
// Текущая дневная прибыль относительно дневного уровня
| |
m_dailyProfit = m_equity - m_baseDailyLevel;
| |
| |
// Текущая общая прибыль относительно базового баланса
| |
m_overallProfit = m_equity - m_baseBalance;
| |
| |
// Если общую прибыль берём относительно наивысшего баланса, то
| |
if(m_calcOverallLossLimit == RM_CALC_OVERALL_LOSS_MONEY_HW_BAL
| |
|| m_calcOverallLossLimit == RM_CALC_OVERALL_LOSS_PERCENT_HW_BAL) {
| |
// Пересчитаем её
| |
m_overallProfit = m_equity - m_baseHWBalance;
| |
}
| |
| |
// Если общую прибыль берём относительно наивысшего баланса или средств, то
| |
if(m_calcOverallLossLimit == RM_CALC_OVERALL_LOSS_MONEY_HW_EQ_BAL
| |
|| m_calcOverallLossLimit == RM_CALC_OVERALL_LOSS_PERCENT_HW_EQ_BAL) {
| |
// Пересчитаем её
| |
m_overallProfit = m_equity - m_baseHWEquityBalance;
| |
}
| |
| |
// Текущая прибыль виртуальных открытых позиций
| |
m_virtualProfit = VirtualProfit();
| |
| |
m_text = StringFormat("Virtual = %10.2f | Profit = %8.2f | Daily = %8.2f | Overall = %8.2f"
| |
" | depoPart = %.2f = %.2f * %.2f * %.2f",
| |
m_virtualProfit, m_profit, m_dailyProfit, m_overallProfit,
| |
m_baseDepoPart * m_dailyDepoPart * m_overallDepoPart,
| |
m_baseDepoPart, m_dailyDepoPart, m_overallDepoPart);
| |
| |
// Раз в час выводим значения в лог
| |
if(IsNewBar(Symbol(), PERIOD_H1)) {
| |
PrintFormat(__FUNCTION__" | %s", m_text);
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Обновление дневных базовых уровней |
| |
//+------------------------------------------------------------------+
| |
void CVirtualRiskManager::UpdateBaseLevels() {
| |
// Обновляем баланс, средства и базовый дневной уровень
| |
m_baseDailyBalance = m_balance;
| |
m_baseDailyEquity = m_equity;
| |
m_baseDailyLevel = MathMax(m_baseDailyBalance, m_baseDailyEquity);
| |
| |
m_dailyProfit = m_equity - m_baseDailyLevel;
| |
| |
PrintFormat(__FUNCTION__" | DAILY UPDATE: Balance = %.2f | Equity = %.2f | Level = %.2f"
| |
" | depoPart = %.2f = %.2f * %.2f * %.2f",
| |
m_baseDailyBalance, m_baseDailyEquity, m_baseDailyLevel,
| |
m_baseDepoPart * m_dailyDepoPart * m_overallDepoPart,
| |
m_baseDepoPart, m_dailyDepoPart, m_overallDepoPart);
| |
| |
// Если ранее был достигнут дневной уровень убытка, то
| |
if(m_state == RM_STATE_DAILY_LOSS) {
| |
// Переходим в состояние восстановления размеров открытых позиций
| |
m_state = RM_STATE_RESTORE;
| |
| |
// Запоминаем время начала восстановления
| |
m_startRestoreTime = TimeCurrent();
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Проверка лимитов убытка |
| |
//+------------------------------------------------------------------+
| |
void CVirtualRiskManager::CheckLimits() {
| |
if(false
| |
|| CheckDailyLossLimit() // Проверка дневного лимита
| |
|| CheckOverallLossLimit() // Проверка общего лимита
| |
|| CheckOverallProfitLimit() // Проверка общей прибыли
| |
) {
| |
// Запоминаем текущий уровень виртуальной прибыли
| |
m_lastVirtualProfit = m_virtualProfit;
| |
| |
// Оповещаем получатель об изменениях
| |
CVirtualReceiver::Instance().Changed();
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Проверка дневного лимита убытка |
| |
//+------------------------------------------------------------------+
| |
bool CVirtualRiskManager::CheckDailyLossLimit() {
| |
// Если достигнут дневной убыток и позиции ещё открыты
| |
if(m_dailyProfit < -DailyLoss() * (1 - m_dailyDepoPart * (1 - m_closeDailyPart))
| |
&& CMoney::DepoPart() > 0) {
| |
| |
// Уменьшаем множитель используемой части общего баланса по дневному убытку
| |
m_dailyDepoPart *= (1 - m_closeDailyPart);
| |
| |
// Если множитель уже слишком мал, то
| |
if(m_dailyDepoPart < 0.05) {
| |
// Устанавливаем его в 0
| |
m_dailyDepoPart = 0;
| |
}
| |
| |
// Устанавливаем значение используемой части общего баланса
| |
SetDepoPart();
| |
| |
PrintFormat(__FUNCTION__" | VirtualProfit = %.2f | Profit = %.2f | Daily Profit = %.2f",
| |
m_virtualProfit, m_profit, m_dailyProfit);
| |
PrintFormat(__FUNCTION__" | RESET: depoPart = %.2f = %.2f * %.2f * %.2f",
| |
m_baseDepoPart * m_dailyDepoPart * m_overallDepoPart,
| |
m_baseDepoPart, m_dailyDepoPart, m_overallDepoPart);
| |
| |
// Устанавливаем риск-менеджер в состояние достигнутого дневного убытка
| |
m_state = RM_STATE_DAILY_LOSS;
| |
| |
return true;
| |
}
| |
| |
return false;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Проверка общего лимита убытка |
| |
//+------------------------------------------------------------------+
| |
bool CVirtualRiskManager::CheckOverallLossLimit() {
| |
// Если достигнут общий убыток и позиции ещё открыты
| |
if(m_overallProfit < -OverallLoss() * (1 - m_overallDepoPart * (1 - m_closeOverallPart))
| |
&& CMoney::DepoPart() > 0) {
| |
// Уменьшаем множитель используемой части общего баланса по общему убытку
| |
m_overallDepoPart *= (1 - m_closeOverallPart);
| |
| |
// Если множитель уже слишком мал, то
| |
if(m_overallDepoPart < 0.05) {
| |
// Устанавливаем его в 0
| |
m_overallDepoPart = 0;
| |
| |
// Устанавливаем риск-менеджер в состояние достигнутого общего убытка
| |
m_state = RM_STATE_OVERALL_LOSS;
| |
}
| |
| |
// Устанавливаем значение используемой части общего баланса
| |
SetDepoPart();
| |
| |
PrintFormat(__FUNCTION__" | VirtualProfit = %.2f | Profit = %.2f | Daily Profit = %.2f",
| |
m_virtualProfit, m_profit, m_dailyProfit);
| |
PrintFormat(__FUNCTION__" | RESET: depoPart = %.2f = %.2f * %.2f * %.2f",
| |
m_baseDepoPart * m_dailyDepoPart * m_overallDepoPart,
| |
m_baseDepoPart, m_dailyDepoPart, m_overallDepoPart);
| |
| |
return true;
| |
}
| |
| |
return false;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Проверка достижения заданной прибыли |
| |
//+------------------------------------------------------------------+
| |
bool CVirtualRiskManager::CheckOverallProfitLimit() {
| |
// Если достигнут общий убыток и позиции ещё открыты
| |
if(m_overallProfit >= OverallProfit() && CMoney::DepoPart() > 0) {
| |
// Уменьшаем множитель используемой части общего баланса по общему убытку
| |
m_overallDepoPart = 0;
| |
| |
// Устанавливаем риск-менеджер в состояние достигнутой общей прибыли
| |
m_state = RM_STATE_OVERALL_PROFIT;
| |
| |
// Устанавливаем значение используемой части общего баланса
| |
SetDepoPart();
| |
| |
PrintFormat(__FUNCTION__" | VirtualProfit = %.2f | Profit = %.2f | Daily Profit = %.2f",
| |
m_virtualProfit, m_profit, m_dailyProfit);
| |
PrintFormat(__FUNCTION__" | RESET: depoPart = %.2f = %.2f * %.2f * %.2f",
| |
m_baseDepoPart * m_dailyDepoPart * m_overallDepoPart,
| |
m_baseDepoPart, m_dailyDepoPart, m_overallDepoPart);
| |
| |
return true;
| |
}
| |
| |
return false;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Определение прибыли открытых виртуальных позиций |
| |
//+------------------------------------------------------------------+
| |
double CVirtualRiskManager::VirtualProfit() {
| |
// Обращаемся к объекту получателя
| |
CVirtualReceiver *m_receiver = CVirtualReceiver::Instance();
| |
| |
// Устанавливаем исходный множитель использования баланса
| |
CMoney::DepoPart(m_baseDepoPart);
| |
| |
double profit = 0;
| |
| |
// Для всех виртуальных позиций находим сумму их прибыли
| |
FOR(m_receiver.OrdersTotal()) profit += CMoney::Profit(m_receiver.Order(i));
| |
| |
// Восстанавливаем текущий множитель использования баланса
| |
SetDepoPart();
| |
| |
return profit;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Определение прибыли виртуальных позиций для восстановления |
| |
//+------------------------------------------------------------------+
| |
double CVirtualRiskManager::RestoreVirtualProfit() {
| |
// Если максимальное время восстановления не задано, то
| |
if(m_maxRestoreTime == 0) {
| |
// Возвращаем текущее значение виртуальной прибыли
| |
return m_virtualProfit;
| |
}
| |
| |
// Находим прошедшее время с начала восстановления в минутах
| |
double t = (TimeCurrent() - m_startRestoreTime) / 60.0;
| |
| |
// Возвращаем расчётное значение желаемой виртуальной прибыли
| |
// в зависимости от прошедшего времени с начала восстановления
| |
return m_lastVirtualProfit * m_lastVirtualProfitFactor * (1 - t / m_maxRestoreTime);
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Установка значения используемой части общего баланса |
| |
//+------------------------------------------------------------------+
| |
void CVirtualRiskManager::SetDepoPart() {
| |
CMoney::DepoPart(m_baseDepoPart * m_dailyDepoPart * m_overallDepoPart);
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Преобразование объекта в строку |
| |
//+------------------------------------------------------------------+
| |
string CVirtualRiskManager::operator~() {
| |
return StringFormat("%s(%s)", typename(this), m_params);
| |
}
| |
//+------------------------------------------------------------------+
|