English
preview
Разработка персонального советника (Часть 3): Управление рисками II — маржа и допустимый риск

Разработка персонального советника (Часть 3): Управление рисками II — маржа и допустимый риск

MetaTrader 5 — Примеры |
28 0
Solomon Anietie Sunday
Solomon Anietie Sunday

Содержание

  1. Введение
  2. Что упустили: риск и маржа — это не одно и то же
  3. Решение 1: Ограничение объема в лотах с учетом доступной свободной маржи
  4. Решение 2: Адаптивный лимит использования маржи
  5. Тестирование проверок маржи
  6. Наводим порядок: единый блок предторговой проверки
  7. Изменения в существующем коде
  8. Итоговые замечания
  9. Заключение


Введение

В части 2 мы заменили фиксированный объем в лотах в советнике на расчет объема позиции по риску. Функция CalculateLotSize() принимает процент риска и текущее расстояние до стоп-лосса, рассчитанное на основе ATR, и возвращает объем в лотах, при котором убыток в случае срабатывания стоп-лосса составляет примерно указанный процент от баланса. Кроме того, мы проверили соответствие расстояния до стоп-лосса минимальному уровню стопов, установленному брокером, ограничили объем с учетом минимального и максимального значений и шага объема, заданных брокером, а также добавили опциональный механизм снижения риска во время просадок. В результате мы получили объем в лотах, корректный с точки зрения риска, но не обязательно обеспеченный доступной на счете маржей. Это разные вещи, и в этой статье мы устраним этот пробел:

  • Объем в лотах, корректный с точки зрения риска, но требующий больше маржи, чем доступно на счете, из-за чего ордер сразу отклоняется.
  • Объем в лотах, для открытия которого маржи достаточно, но который задействует почти всю свободную маржу, подвергая счет риску маржин-колла.
  • Логика проверки разбросана по всей функции OpenPosition(), и нет единого места, которое можно было бы назвать "последней проверкой перед открытием сделки".

В данной статье предполагается, что вы используете советник, созданный в части 2, и хорошо знакомы с функцией CalculateLotSize(). Как всегда, логика пересечения скользящих средних остается без изменений, поскольку эта статья посвящена не торговой стратегии.

Предмет данной статьи

К концу этой части у нас будет следующее:

  • Проверка маржи, ограничивающая объем в лотах, полученный при расчете объема позиции по риску, величиной, которую фактически позволяет обеспечить свободная маржа.
  • Настраиваемый лимит с жестким нижним порогом, ниже которого сделка пропускается, а не уменьшается ее объем.
  • Опциональный адаптивный механизм, который ужесточает лимит использования маржи по мере снижения уровня маржи на счете.
  • Единый блок предторговой проверки с отдельным именем, объединяющий проверку позиций, расчет объема позиции по риску и проверку маржи.

Все это применимо не только к пересечению скользящих средних. Любому советнику, который рассчитывает объем в лотах перед отправкой ордера, нужна такая же проверка.


Что упустили: риск и маржа — это не одно и то же

Риск — это деньги, которые вы потеряете в случае срабатывания стоп-лосса. Маржа — это средства, которые блокируются в момент открытия позиции, независимо от того, принесет ли сделка прибыль, убыток или закроется без прибыли и убытка. Это два отдельных ограничения для одной и той же сделки, и в предыдущей части серии было учтено только первое из них.

Функция CalculateLotSize() не учитывает маржу. Она считывает баланс и применяет заданный процент риска. Она преобразует расстояние до стоп-лосса в денежный риск на один лот, затем выполняет деление и округляет результат в соответствии с требованиями брокера к объему. Свободная маржа в ней нигде не учитывается. MetaTrader позволит советнику сформировать ордер с объемом, для которого на счете недостаточно средств, и отклонит его уже торговый сервер. Вот как это выглядит на практике.

Проблема 1: Близкий стоп-лосс увеличивает объем в лотах

Обычно это происходит в условиях, когда рынок выглядит спокойным. Низкая волатильность означает небольшое значение ATR, малое расстояние до стоп-лосса и, следовательно, очень низкий риск на один лот на каждый пункт движения цены в неблагоприятную сторону. Чтобы при срабатывании столь близкого стоп-лосса убыток все же составил заданный процент, функция CalculateLotSize() должна рассчитать больший объем в лотах, чем при более удаленном стоп-лоссе. Для большего объема в лотах требуется больше маржи, и на небольшом счете требуемая маржа может превышать фактически доступную свободную маржу.

Чтобы проиллюстрировать этот механизм, возьмем торговый инструмент, для которого риск на один стандартный лот составляет примерно 10 долларов на пипс, счет на 2 000 долларов с кредитным плечом 1:100 и риск на сделку в размере 1 %, что дает бюджет риска в 20 долларов:

  • При расстоянии до стоп-лосса в 20 пипсов риск на один лот составляет 200 долларов, поэтому бюджет риска в 20 долларов дает объем сделки 0.10 лота, для которого требуется около 100 долларов маржи.
  • Если сократить расстояние до стоп-лосса до 8 пипсов, риск на один лот составит 80 долларов, поэтому тот же бюджет риска в 20 долларов даст объем сделки 0.25 лота, для которого потребуется около 250 долларов маржи.

Риск остался прежним, но требуемая маржа выросла более чем вдвое. На небольшом счете именно попытка совершить вторую сделку приводит к возврату кода TRADE_RETCODE_NO_MONEY, и модель риска, которая на бумаге выглядела правильной, не позволяет совершить сделку.

Проблема 2: Средств хватает, но впритык

Менее заметная проблема возникает, когда средств для рассчитанного объема в лотах хватает, но он задействует почти всю свободную маржу. В результате одного движения цены в неблагоприятную сторону может оказаться достаточно для маржин-колла. Параметр RiskPercent этого никак не учитывает. Он определяет размер убытка, который будет зафиксирован при срабатывании стоп-лосса, а не сумму капитала, задействованного, пока позиция открыта. Сделка может подвергать риску 1 % от баланса и при этом задействовать большую часть свободной маржи, а советник в его нынешнем виде никак не реагирует на это.

Проблема 3: Советник видит только собственные сделки

Функция CalculateLotSize() рассчитывает объем каждой сделки так, будто она единственная на счете. Обычно это не так. Сделка, открытая вручную, второй советник на другом графике или встречная позиция, открытая самим этим советником, поскольку в нем предусмотрена опция AllowHedging, — все это задействует маржу, которую расчет для одной изолированной сделки не учитывает.

Решение для всех трех проблем одно: перед отправкой ордера проверить, какой объем фактически позволяют открыть доступные на счете средства, и соответственно скорректировать объем сделки.


Решение 1: Ограничение объема в лотах с учетом доступной свободной маржи

План прост. После того как функция CalculateLotSize() рассчитывает объем в лотах по риску, это значение передается во вторую функцию, которая определяет максимальный объем, допустимый с учетом свободной маржи, и возвращает меньшее из двух значений.

Добавление входного параметра

Новый входной параметр определяет, какую долю свободной маржи может задействовать отдельная сделка:

input double MaxMarginUsagePercent   = 50.0;      // Max % of free margin one new trade may use

Значение по умолчанию — 50 % — выбрано не случайно. Без лимита использования маржи объем одной сделки можно рассчитать так, что она задействует всю свободную маржу до последнего доллара. Лимит использования маржи на уровне 50 % оставляет на счете запас даже при сделке максимального объема.

Расчет маржи для одного лота с помощью OrderCalcMargin()

Чтобы узнать, какой объем в лотах нам доступен, сначала нужно определить, сколько маржи требуется для одного лота:

//--- Margin required for a single lot
   double marginPerLot = 0.0;
   ResetLastError();
   if(!OrderCalcMargin(orderType, _Symbol, 1.0, price, marginPerLot) || marginPerLot <= 0.0)
     {
      PrintFormat("%s: OrderCalcMargin() failed. Error %d", __FUNCTION__, GetLastError());
      return 0.0;
     }

Функция OrderCalcMargin() принимает тип ордера, торговый инструмент, объем и цену; при успешном выполнении возвращает true и записывает требуемую маржу в последний параметр.

Следует отметить две вещи. Во-первых, мы запрашиваем маржу именно для одного лота, а не для предварительно рассчитанного объема в лотах. Маржа для рыночного ордера линейно зависит от объема, поэтому, зная маржу для одного лота, можно рассчитать любой допустимый объем в лотах; выполнить один запрос и затем деление проще, чем подбирать подходящий объем пробными запросами. Это распространенный подход к расчету объема позиции с учетом маржи в MQL5. Во-вторых, мы не рассчитываем маржу вручную на основе кредитного плеча и размера контракта. Функция OrderCalcMargin() уже учитывает оба параметра, а также ставку маржи для торгового инструмента и необходимую конвертацию валют. Самостоятельная реализация расчетов на основе исходных спецификаций приводит к тому, что советники начинают незаметно работать некорректно на первом же незнакомом торговом инструменте.

Расчет максимального объема в лотах по свободной марже

Зная маржу для одного лота, можно рассчитать доступный объем по нескольким показателям счета и торгового инструмента:

 double marginCapPercent = GetMarginUsageCap();
   if(marginCapPercent <= 0.0)
     {
      Print("Margin check: account margin level is too low for new exposure. Trade skipped.");
      return 0.0;
     }

   double freeMargin    = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
   double usedMargin    = AccountInfoDouble(ACCOUNT_MARGIN);
   double allowedMargin = freeMargin * (marginCapPercent / 100.0);

   double minLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);

   double maxAffordableLot = MathFloor((allowedMargin / marginPerLot) / lotStep) * lotStep;

ACCOUNT_MARGIN_FREE — это свободная маржа, доступная для открытия новых позиций. ACCOUNT_MARGIN — это использованная маржа; она не участвует в расчетах, но выводится в журнал, поскольку трейдеру, читающему запись об изменении объема сделки, важно знать, какая часть средств на счете уже задействована.

Последняя строка выполняет две задачи. Деление допустимой маржи на маржу для одного лота дает исходный доступный объем; деление этого объема на lotStep, округление результата вниз до целого и обратное умножение на шаг объема округляют его вниз до значения, допустимого у брокера. MathFloor() гарантирует, что округление вверх даже на один шаг вновь привело бы к превышению только что рассчитанного лимита использования маржи.

Полная функция

//+------------------------------------------------------------------+
//| Cap the risk-based lot size to the account's free margin         |
//+------------------------------------------------------------------+
double ValidateMarginForLot(ENUM_ORDER_TYPE orderType, double lotSize, double price)
  {
//--- Margin required for a single lot
   double marginPerLot = 0.0;
   ResetLastError();
   if(!OrderCalcMargin(orderType, _Symbol, 1.0, price, marginPerLot) || marginPerLot <= 0.0)
     {
      PrintFormat("%s: OrderCalcMargin() failed. Error %d", __FUNCTION__, GetLastError());
      return 0.0;
     }

   double marginCapPercent = MaxMarginUsagePercent;

   double freeMargin    = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
   double usedMargin    = AccountInfoDouble(ACCOUNT_MARGIN);
   double allowedMargin = freeMargin * (marginCapPercent / 100.0);

   double minLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);

   double maxAffordableLot = MathFloor((allowedMargin / marginPerLot) / lotStep) * lotStep;

   if(maxAffordableLot < minLot)
     {
      //--- Leverage and contract size aren't used in the calculation but only for logging
      long   leverage     = AccountInfoInteger(ACCOUNT_LEVERAGE);
      double contractSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_CONTRACT_SIZE);
      PrintFormat("Margin check: cannot safely support even the minimum lot (%.2f).", minLot);
      PrintFormat("Free: %.2f | Used: %.2f | Leverage: 1:%d | Contract Size: %.0f. Trade skipped.",
                  freeMargin, usedMargin, (int)leverage, contractSize);
      return 0.0;
     }

   if(lotSize > maxAffordableLot)
     {
      PrintFormat("Margin check: risk-based lot %.2f exceeds the %.1f%% margin-usage cap.", lotSize, marginCapPercent);
      PrintFormat("Free: %.2f | Used: %.2f | %.2f lots affordable. Reducing to %.2f.",
                  freeMargin, usedMargin, maxAffordableLot, maxAffordableLot);
      return maxAffordableLot;
     }

   return lotSize;
  }

Именно в двух ветвях в середине функции реализованы правила принятия решений. Первая ветвь срабатывает, когда даже минимальный допустимый у брокера объем нельзя обеспечить маржой без превышения безопасного лимита. Меньшего допустимого объема нет, поэтому сделка пропускается. Кредитное плечо и размер контракта указаны в этой строке журнала лишь потому, что они не участвуют в расчете напрямую. Функция OrderCalcMargin() уже учла их, но при отказе в открытии сделки обычно возникают вопросы: сколько свободной маржи, какое кредитное плечо и каков размер контракта у торгового инструмента. Вторая ветвь срабатывает, когда объем в лотах, рассчитанный по риску, превышает объем, доступный по марже. В этом случае советник уменьшает объем позиции, а не отклоняет сделку, поскольку сделка меньшего допустимого объема лучше, чем отсутствие сделки. В результате трейдер принимает на себя меньшую рыночную экспозицию, чем задан параметром RiskPercent, а в журнале это отмечается с указанием числовых значений, объясняющих причину.

Внедрение новой функции

Функция вызывается внутри OpenPosition() сразу после расчета объема в лотах, поскольку это значение требуется ей в качестве входного параметра. Тип ордера определяется направлением сделки, которое советник уже определил:

//--- Lot size from the validated stop distance
   double lotSize = CalculateLotSize(stopDistance);
   if(lotSize <= 0)
     {
      Print("Calculated lot size is invalid. Trade skipped.");
      return;
     }

//--- Cap the lot to what free margin can safely support
   ENUM_ORDER_TYPE orderType = (direction == 1) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
   lotSize = ValidateMarginForLot(orderType, lotSize, price);
   if(lotSize <= 0)
     {
      Print("Trade skipped: insufficient free margin to safely open a position.");
      return;
     }

Расчет объема позиции по риску отвечает на вопрос: "Какой объем в лотах соответствует убытку, который я готов понести?" Проверка маржи отвечает на вопрос: "Могу ли я действительно держать открытой позицию такого объема?" Для проверки маржи нужен результат расчета объема позиции по риску, поэтому она выполняется после него, а не до.


Решение 2: адаптивный лимит использования маржи

Фиксированный лимит использования маржи в 50 % применяется одинаково и к счету в благополучном состоянии, и к счету под нагрузкой. Этот подход можно улучшить, используя ту же схему, что и в адаптивном механизме управления риском из части 2: фиксированный входной параметр, возможность переопределить его значение и плавная корректировка между двумя порогами.

Сигнал: уровень маржи

Корректировка выполняется в зависимости от ACCOUNT_MARGIN_LEVEL — показателя, который MetaTrader рассчитывает как отношение средств к использованной марже, выраженное в процентах. Высокое значение означает, что средства значительно превышают использованную маржу; низкое — что счет близок к маржин-коллу. Этот показатель характеризует весь счет и учитывает все открытые на нем позиции, а не только позиции данного советника. Поэтому он подходит для решения проблемы 3, в которой именно рыночная экспозиция, не видимая советнику, делает счет уязвимым.

Добавление входных параметров

input bool   EnableAdaptiveMarginCap = false;     // Scale the margin cap with account-wide margin level
input double MarginLevelSafe         = 500.0;     // Margin safe level [%] full cap applies
input double MarginLevelDanger       = 150.0;     // Margin caution level [%] new trades are blocked

Этот адаптивный механизм управления риском необязателен, поэтому по умолчанию он отключен. Оставьте параметр EnableAdaptiveMarginCap равным false, и советник будет вести себя точно так же, как после исправления 1.

Создание функции

//+------------------------------------------------------------------+
//| Return the margin-usage cap [%] this trade may consume.          |
//+------------------------------------------------------------------+
double GetMarginUsageCap()
  {
   if(!EnableAdaptiveMarginCap)
      return MaxMarginUsagePercent;

//--- No margin currently used anywhere on the account (flat)
   double marginUsed = AccountInfoDouble(ACCOUNT_MARGIN);
   if(marginUsed <= 0.0)
      return MaxMarginUsagePercent;

   double marginLevel = AccountInfoDouble(ACCOUNT_MARGIN_LEVEL);

//--- Account-wide margin level already stressed - block new exposure
   if(marginLevel <= MarginLevelDanger)
     {
      PrintFormat("Adaptive Margin Cap | Margin Level: %.1f%% at/below danger threshold (%.1f%%).",
                  marginLevel, MarginLevelDanger);
      return 0.0;
     }

//--- Margin level healthy - full cap applies
   if(marginLevel >= MarginLevelSafe)
      return MaxMarginUsagePercent;

//--- Scale linearly between the danger and safe thresholds
   double ratio = (marginLevel - MarginLevelDanger) / (MarginLevelSafe - MarginLevelDanger);
   double cap = MaxMarginUsagePercent * ratio;

   PrintFormat("Adaptive Margin Cap | Margin Level: %.1f%% | Cap Scaled To: %.1f%% (baseline %.1f%%)",
               marginLevel, cap, MaxMarginUsagePercent);

   return cap;
  }

Если просматривать код сверху вниз, в функции предусмотрены четыре варианта выхода:

  • Адаптивный режим отключен: вернуть фиксированное значение входного параметра без изменений.
  • Маржа нигде не используется: на счете нет открытых позиций, поэтому деление средств на нулевую использованную маржу не дает полезной информации. Вернуть базовый лимит использования маржи.
  • Если уровень маржи равен MarginLevelDanger или ниже, вернуть 0.0, заблокировав сделку. Проблема здесь не в объеме сделки: на счете вообще не следует наращивать рыночную экспозицию.
  • Между двумя порогами (безопасным и опасным уровнями): уменьшать лимит использования маржи пропорционально тому, насколько глубоко уровень маржи счета опустился в этот диапазон.

Именно ради этого последнего случая и создана функция. Без этого советник резко переходил бы от полного разрешения новых сделок при уровне маржи 151% к их полной блокировке при 150%. С этой функцией для счета с уровнем маржи 325% — посередине между порогами — применяется половина базового лимита использования маржи, так что заданный по умолчанию лимит 50% становится равным 25%.

Интеграция функции

Изменяется только одна строка внутри функции ValidateMarginForLot(). Было:

   double marginCapPercent = MaxMarginUsagePercent;

Стало:

   double marginCapPercent = GetMarginUsageCap();
   if(marginCapPercent <= 0.0)
     {
      Print("Margin check: account margin level is too low for new exposure. Trade skipped.");
      return 0.0;
     }

Весь последующий код уже использует marginCapPercent. Строка журнала, сообщающая лимит использования маржи, теперь выводит скорректированное значение вместо исходного значения входного параметра. Именно новая защитная проверка обеспечивает пропуск сделки, когда GetMarginUsageCap() возвращает 0.0. Таким образом, вызывающей функции не нужно знать, включен ли адаптивный режим: она просто запрашивает число и использует его.


Тестирование проверок маржи

Было выполнено три прогона в тестере стратегий, каждый из которых проверял отдельный путь выполнения двух функций. Специально для этих прогонов значение RiskPercent было увеличено до 2 %, чтобы рассчитанный по риску объем в лотах оказался достаточно большим для срабатывания лимита использования маржи.

Настройка теста на уровне 2 % была выбрана для наглядности работы механизма, а не в качестве рекомендуемого значения для реальной эксплуатации.

Тестирование лимита использования свободной маржи: входные параметры

Тест 1: фиксированный лимит использования маржи

Для параметра MaxMarginUsagePercent задано значение по умолчанию — 50 %, адаптивный режим отключен. При появлении сигнала рассчитанный по риску объем составил 11.11 лота, что значительно превышало объем, который можно было обеспечить половиной свободной маржи. Проверка маржи выявила это превышение, и сделка была выполнена с объемом 1.99 лота, соответствующим доступному объему, рассчитанному функцией ValidateMarginForLot().

Тестирование лимита использования свободной маржи: журналы

Тест 2: адаптивный лимит использования маржи

Параметр EnableAdaptiveMarginCap включен, для параметра MarginLevelDanger задано значение по умолчанию — 150 %. В ходе прогона уровень маржи на счете составлял 140 %, то есть был ниже порога опасности, и новые сделки вообще не открывались. Это означает, что функция GetMarginUsageCap() вернула 0.0, а защитная проверка в функции ValidateMarginForLot() привела к пропуску сделки.

Тестирование адаптивного лимита использования маржи: входные параметры

Тестирование адаптивного лимита использования маржи: журнал

Тест 3: адаптивное масштабирование

Позже в ходе того же прогона уровень маржи составил примерно 450 %, что выше порога опасности, но ниже значения MarginLevelSafe. Лимит использования маржи был снижен с базовых 50 % примерно до 43 %, а завышенный объем в лотах был уменьшен с учетом этого скорректированного значения, а не базового.

Тестирование адаптивного масштабирования: журналы

В приведенной ниже таблице непосредственно представлены результаты тестирования:

Тест Настройки Объем в лотах по риску РЕЗУЛЬТАТЫ
Фиксированный лимит использования маржи. MaxMarginUsagePercent = 50, адаптивный режим выключен. 11.11 лота Объем уменьшен до 1.99 лота
Адаптивный лимит использования маржи, уровень маржи ниже опасного порога. Адаптивный режим включен, уровень маржи 140 % (ниже опасного порога 150 %). —
Сделка полностью заблокирована, позиция не открыта.
Адаптивный лимит использования маржи, пропорционально уменьшенный. Адаптивный режим включен, уровень маржи ~450 % (находится между пороговыми значениями: безопасный уровень — 500 %, опасный уровень — 150 %). 2.5 лота Лимит снижен примерно до 43 %; объем, требовавший больше допустимой маржи, уменьшен до 2,41 лота.

Все три сценария — уменьшение объема, полная блокировка и уменьшение объема с учетом адаптивного лимита — сработали как задумано.


Наводим порядок: единый блок предторговой проверки

Предыдущая часть серии завершилась вынесением функции OpenPositions() из функции OnTick(), поскольку одна и та же логика дублировалась в ветвях покупки и продажи. Эта часть заканчивается аналогичным упорядочением кода, но по другой причине.

Теперь функция OpenPosition() еще до формирования торгового запроса выполняет три независимые проверки: проверку лимита числа позиций из части 1, расчет объема позиции по риску из части 2 и проверку лимита использования маржи из этой части. Каждая из них может заблокировать сделку. Функционально эти три проверки образуют итоговый единый блок предторговой проверки. Раньше это были просто последовательные операторы внутри функции, предназначенной для отправки ордера. Не было отдельного блока, которому можно было бы дать имя.

//+------------------------------------------------------------------+
//| Final pre-trade validation gate.                                 |
//+------------------------------------------------------------------+
bool PassesPreTradeValidation(int direction, double stopDistance, double price, double &validatedLotSize)
  {
   validatedLotSize = 0.0;

//--- Position awareness check, same rule as Part 1
   bool canOpenTrade = false;
   if(AllowHedging)
      canOpenTrade = (CountOpenPositionsByDirection(direction) == 0);
   else
      canOpenTrade = (CountOpenPositions() == 0);

   if(!canOpenTrade)
      return false;

//--- Lot size from the validated stop distance
   double lotSize = CalculateLotSize(stopDistance);
   if(lotSize <= 0)
     {
      Print("Calculated lot size is invalid. Trade skipped.");
      return false;
     }

//--- Cap the lot to what free margin can safely support
   ENUM_ORDER_TYPE orderType = (direction == 1) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
   lotSize = ValidateMarginForLot(orderType, lotSize, price);
   if(lotSize <= 0)
     {
      Print("Trade skipped: insufficient free margin to safely open a position.");
      return false;
     }

   validatedLotSize = lotSize;
   return true;
  }

Функция возвращает значение типа bool, отражающее принятое решение, и записывает итоговый объем в лотах в переменную validatedLotSize, переданную по ссылке, так что один вызов отвечает на оба вопроса: "Следует ли совершать эту сделку?" и "Каким объемом?"

Как сейчас выглядит функция OpenPosition()

//+------------------------------------------------------------------+
//| Size, validate, and open a trade in the given direction          |
//| direction: 1 = Buy, -1 = Sell                                    |
//+------------------------------------------------------------------+
void OpenPosition(int direction, double price, double stopDistance, int digits)
  {
   double lotSize = 0.0;
   if(!PassesPreTradeValidation(direction, stopDistance, price, lotSize))
      return;

//--- SL/TP and execution, direction-specific
   double sl, tp;
   if(direction == 1)
     {
      sl = NormalizeDouble(price - stopDistance, digits);
      tp = NormalizeDouble(price + (stopDistance * TPRatio), digits);
      if(!trade.Buy(lotSize, _Symbol, 0.0, sl, tp, "Fixed EA Buy"))
         PrintFormat("Buy failed. Retcode: %u (%s)", trade.ResultRetcode(),
                     trade.ResultRetcodeDescription());
     }
   else
     {
      sl = NormalizeDouble(price + stopDistance, digits);
      tp = NormalizeDouble(price - (stopDistance * TPRatio), digits);
      if(!trade.Sell(lotSize, _Symbol, 0.0, sl, tp, "Fixed EA Sell"))
         PrintFormat("Sell failed. Retcode: %u (%s)", trade.ResultRetcode(),
                     trade.ResultRetcodeDescription());
     }
  }

Функция OpenPosition() больше не содержит собственной логики проверки. Она обращается к единому блоку предторговой проверки, чтобы определить, следует ли совершать сделку; если да, то рассчитывает стопы и отправляет ордер. Это рефакторинг с сохранением поведения. Ничего не изменилось ни в отношении момента открытия сделки, ни в отношении её объёма. Те же три проверки выполняются в том же порядке и дают те же результаты. Изменилось лишь то, что теперь они вынесены в отдельную именованную функцию.

В этом и заключается практическая польза "разделения ответственности" — принципа, который легко считать абстракцией, пока его несоблюдение не обойдется вам дорого. На приведенном ниже изображении это хорошо видно:

Блок-схема предторговой проверки

Полный путь от обнаруженного сигнала до отправки ордера или записи в журнале о причине отказа:

  1. Функция OnTick() обнаруживает пересечение скользящих средних и вызывает OpenPosition().
  2. Функция OpenPosition() вызывает PassesPreTradeValidation().
  3. Внутри единого блока предторговой проверки: сначала проверка лимита количества позиций, затем расчет объема позиции по риску, затем применение лимита использования маржи.
  4. При успешном прохождении проверок validateLotSize содержит итоговый объем в лотах, а функция OpenPosition() рассчитывает стопы и отправляет ордер.
  5. Если любая из проверок не пройдена, единый блок предторговой проверки возвращает false, после чего запись в журнале поясняет, какая проверка не позволила совершить сделку, и дальнейшие действия не выполняются.


Изменения в существующем коде

С внедрением новой логики появились два небольших изменения. Ни одно из этих изменений не влияет на торговую логику, но оба важны для советника, который продолжает развиваться.

Группировка входных параметров

В предыдущих частях входные параметры представляли собой единый список из двенадцати параметров, разделенных лишь пустой строкой. Если добавить ещё четыре, то их число достигнет шестнадцати. Теперь блок входных параметров разбит с помощью input group на разделы: "Торговый сигнал" (Trading Signal), "Настройки торговли и риска" (Trade & Risk Settings), "Адаптивный риск (Просадка)" (Adaptive Risk (Drawdown)), "Ограничения брокера и контроль маржи" (Broker & Margin Safety) и "Общие" (General).

input group "Broker & Margin Safety"
input double MaxMarginUsagePercent   = 50.0;      // Max % of free margin one new trade may use
input bool   EnableAdaptiveMarginCap = false;     // Scale the margin cap with account-wide margin level
input double MarginLevelSafe         = 500.0;     // Margin safe level [%] full cap applies
input double MarginLevelDanger       = 150.0;     // Margin caution level [%] new trades are blocked

Группы входных параметров никак не влияют на работу советника. Это влияет лишь на отображение параметров на вкладке "Входные параметры" в MetaTrader: вместо одного длинного неструктурированного столбца они представлены в сворачиваемых группах с заголовками. На начальном этапе, когда пять входных параметров без труда помещаются на экране, группировку легко отложить, но она становится необходимой, как только число параметров достигает десяти и они начинают относиться к разным аспектам работы советника. Если вам становится сложно просматривать входные параметры советника, добавьте группировку сейчас, не дожидаясь, пока список станет нечитаемым.

Две новые проверки при запуске

В функции OnInit() добавлены две проверки:

   if(MaxMarginUsagePercent <= 0 || MaxMarginUsagePercent > 100)
     {
      Print("MaxMarginUsagePercent must be between 0 and 100.");
      return INIT_PARAMETERS_INCORRECT;
     }

   if(EnableAdaptiveMarginCap && MarginLevelSafe <= MarginLevelDanger)
     {
      Print("MarginLevelSafe must be greater than MarginLevelDanger.");
      return INIT_PARAMETERS_INCORRECT;
     }

Обе проверки позволяют сразу прервать инициализацию при ошибках в настройках, вместо того чтобы обнаруживать их позже, во время работы советника. Первая проверка определяет, не выходит ли процент использования маржи на одну сделку за пределы диапазона от 0 до 100. Жестко заданный лимит использования маржи в 100 % — разумное значение по умолчанию для большинства трейдеров. Вторая проверка важна, поскольку определяет, не меньше ли MarginLevelSafe значения MarginLevelDanger и не равно ли ему: в таком случае расчет масштабирования в GetMarginUsageCap() привел бы к делению на ноль или к отрицательному коэффициенту.

Примечание об уровне стопов и уровне заморозки

Такие ограничения брокера, как минимальный объем, шаг объема, уровень стопов и уровень заморозки, часто перечисляют вместе, как будто все они применяются в один и тот же момент. Это не так: данный советник учитывает одно из двух последних ограничений, намеренно не проверяя другое.

SYMBOL_TRADE_STOPS_LEVEL, рассмотренный в части 2, задает минимально допустимое расстояние от текущей цены до стоп-лосса при открытии позиции. Это напрямую относится к тому, что советник делает при каждой сделке. У SYMBOL_TRADE_FREEZE_LEVEL другое назначение. Это свойство ограничивает изменение или удаление стоп-лосса существующей позиции либо отложенного ордера, когда цена приближается к ним. Оно не накладывает ограничений на открытие нового рыночного ордера.

Этот советник никогда не изменяет существующую позицию и никогда не размещает отложенный ордер, поэтому проверка уровня заморозки в данном случае защитила бы от сценария, который в этом коде просто не может произойти. Ситуация изменится с добавлением трейлинг-стопов, поскольку трейлинг-стоп выполняет именно то действие, которое ограничивает уровень заморозки: изменяет стоп-лосс уже открытой позиции. Именно там и нужна эта проверка, и именно там она появится в следующих статьях серии.


Итоговые замечания

Распространенные ошибки и способы их устранения

Ошибка Решение
Предположение, что корректно рассчитанный по риску объем в лотах автоматически позволяет открыть сделку.
Перед отправкой ордера проверьте с помощью OrderCalcMargin(), достаточно ли свободной маржи для выбранного объема в лотах.
Расчет требуемой маржи вручную на основе кредитного плеча и размера контракта.
Используйте функцию OrderCalcMargin(), которая уже учитывает и то, и другое, а также ставку маржи и конвертацию валют.
Использование всей доступной свободной маржи для одной планируемой сделки.
Ограничьте использование маржи для одной сделки настраиваемым процентом от свободной маржи.
Округление доступного по марже объема в лотах вверх до ближайшего значения, кратного шагу объема.
Округляйте вниз с помощью MathFloor(); округление вверх снова приведет к превышению лимита использования маржи для сделки.
Уменьшение объема в лотах без уведомления или безусловный отказ от сделки всякий раз, когда требуемая маржа превышает лимит.
Уменьшите объем в лотах до доступного по марже и запишите в журнал исходный объем, лимит использования маржи и итоговый объем; пропускайте сделку только тогда, когда маржи недостаточно даже для минимального объема.
Выполнение проверки маржи до расчета риска.
Сначала рассчитайте объем позиции по риску, затем ограничьте его с учетом маржи. Для проверки маржи в качестве входных данных требуется объем в лотах, рассчитанный по риску.
Реализация проверки брокерских ограничений для сценария, который невозможен в этом советнике.
Реализуйте проверки ограничений, с которыми код действительно сталкивается; остальные ограничения опишите, указав, в какой части кода они будут применяться.


Чего этот советник пока не может делать

Функция OrderCalcMargin() рассчитывает необходимую маржу так, как будто на счете нет других позиций или отложенных ордеров. На счете, на котором уже открыты позиции, фактически использованная маржа может отличаться от данного показателя, рассчитанного отдельно для каждой сделки.

Следует точно указать, от какой настройки это зависит. Параметр AllowHedging в этом советнике определяет лишь то, разрешает ли сам советник открывать встречные позиции; он не указывает на фактический режим счета ACCOUNT_MARGIN_MODE. На неттинговом счете по каждому торговому инструменту может существовать только одна совокупная позиция, поэтому оценка, рассчитанная отдельно для каждой сделки, как правило, остается близкой к фактической рыночной экспозиции счета. На хеджинговом счете по одному и тому же торговому инструменту могут одновременно существовать несколько позиций, для каждой из которых маржа рассчитывается отдельно, поэтому допущение об отсутствии других позиций хуже отражает фактическую потребность счета в марже. Поэтому на хеджинговом счете при AllowHedging = true рассматривайте значения маржи, записанные в журнал, как оценки для отдельных сделок. Не следует рассматривать их как фактический доступный запас средств на счете. Проверка маржи на уровне портфеля для нескольких позиций, открытых одновременно, не поддерживается. Этот вопрос будет рассмотрен, когда в этой серии статей мы перейдем от риска отдельной сделки к риску всей стратегии.

Функция ValidateMarginForLot() рассчитывает требуемую маржу только для рыночных ордеров на покупку и продажу — именно такие ордера сейчас отправляет этот советник. Отложенные ордера, размещаемые по ценам, отличным от текущей рыночной цены, не обрабатываются, а расчет объема позиции с учетом типа ордера — естественная следующая тема в управлении рисками. Как уже отмечалось выше, проверка уровня заморозки не реализована, поскольку в этом советнике пока нет операций, к которым она применялась бы.


Заключение

Объем позиции может быть корректным с точки зрения риска, но при этом не подходить для данного счета. Данная статья устраняет этот пробел, включая маржу в процесс принятия торговых решений. Теперь советник берет объем в лотах, полученный при расчете объема позиции по риску, проверяет, какой объем счет может безопасно обеспечить маржой, при необходимости уменьшает его и пропускает сделку, если маржи недостаточно даже для минимального объема, установленного брокером. Опциональный адаптивный лимит использования маржи обеспечивает дополнительный уровень защиты, снижая этот лимит по мере снижения уровня маржи на счете.

Это делает переход от сигнала к исполнению сделки более понятным и безопасным. Теперь проверка лимитов позиций, расчет объема позиции по риску и проверка маржи объединены в единый блок предторговой проверки PassesPreTradeValidation() , который выполняется до формирования ордера. Советник также сообщает числовые значения, на основании которых сделка была отклонена или ее объем уменьшен, поэтому ситуация, когда сделка не открывается, больше не остается без объяснения. При этом важно учитывать ограничения реализации: расчет маржи по-прежнему дает лишь изолированную оценку и не отражает полной картины рыночной экспозиции всего портфеля, особенно на хеджинговых счетах с несколькими позициями.

Важное различие состоит в том, что расчет объема позиции по риску определяет сумму, которой следует рисковать в сделке, а проверка маржи — способен ли счет обеспечить эту сделку маржой без чрезмерной нагрузки. Обе проверки должны выполняться до того, как ордер поступит на торговый сервер.

Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/23897

Прикрепленные файлы |
Автоматизация классических рыночных методов на MQL5 (Часть 6): Система ключевых точек Джесси Ливермора Автоматизация классических рыночных методов на MQL5 (Часть 6): Система ключевых точек Джесси Ливермора
В данной статье представлен готовый советник на языке MQL5, в котором «рыночный ключ» Джесси Ливермора реализован в виде детерминированного конечного автомата. Он определяет ключевые уровни по консолидациям, используя ATR и рост объема, поэтапно наращивает позиции четырьмя траншами и закрывает их при аномальном поведении, определяемом по диапазону и объему. Советник проверяет входные параметры в OnInit, требует хеджингового счета и компилируется без дополнительных доработок для тестирования правил Ливермора на дневных данных.
Фильтр Калмана для сглаживания цены: точная реализация на MQL5 Фильтр Калмана для сглаживания цены: точная реализация на MQL5
В данной статье реализован скалярный фильтр Калмана для сглаживания цены в MQL5 с использованием стандартной модели локального уровня и точных уравнений прогнозирования и коррекции. В статье объясняется, как шум процесса и шум измерения (Q, R) определяют коэффициент усиления Калмана, два независимо настроенных фильтра объединяются в систему на основе пересечения быстрой и медленной линий, а также приводятся полностью реализованные индикатор и советник. Советник получает данные индикатора через iCustom и торгует по сигналу, подтвержденному правилом устойчивости. Это дает воспроизводимую основу для тестирования и настройки.
Торговые инструменты MQL5 (Часть 36): Фигуры и аннотации в слое рисования с редактированием меток прямо на холсте Торговые инструменты MQL5 (Часть 36): Фигуры и аннотации в слое рисования с редактированием меток прямо на холсте
Мы добавляем на холст восемь инструментов для рисования фигур и девять инструментов для создания аннотаций, а также реализуем полнофункциональную систему редактирования меток на месте. В статье подробно рассматриваются геометрия, отрисовка со сглаживанием, общие вспомогательные функции для переноса слов и отрисовки текста с суперсэмплингом, а также конечный автомат редактирования, основанный на положении текстового курсора и отвечающий за ввод текста, навигацию и выделение. В результате получается полный и согласованный набор инструментов для аннотирования с редактируемыми метками, который интегрируется в существующий конвейер взаимодействия.
Создание пользовательских индикаторов для начинающих (Часть 2): Индикатор на основе преобразования Фишера Создание пользовательских индикаторов для начинающих (Часть 2): Индикатор на основе преобразования Фишера
В этой статье индикатор на основе преобразования Фишера разрабатывается на языке MQL5 начиная с базовых принципов: цена нормализуется относительно диапазона между максимумом и минимумом за последние бары, затем полученное значение сглаживается и ограничивается по диапазону, после чего к нему применяется логарифмическое преобразование. Мы рассмотрим привязку буферов, управление состоянием расчетного буфера при переходе от бара к бару и инициализацию для стабильного начала расчетов. В сопутствующем советнике реализована проверка достижения порога и подтверждения разворота, чтобы показать, как использовать сигнал для торговли.