English
preview
Разработка собственного торгового советника (Часть 4): Управление рисками III — модели риска и исполнение ордеров

Разработка собственного торгового советника (Часть 4): Управление рисками III — модели риска и исполнение ордеров

MetaTrader 5 — Трейдинг |
23 0
Solomon Anietie Sunday
Solomon Anietie Sunday

Содержание

  1. Введение
  2. Что на самом деле означает «риск на сделку»
  3. Второе допущение: сделка заключается прямо сейчас
  4. Планирование — проверка — исполнение
  5. Проверка
  6. Несколько слов обо всех этих входных параметрах
  7. Заключение


Введение

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

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


Что на самом деле означает «риск на сделку»

Спросите трех трейдеров, как они определяют риск на сделку, и вы вполне можете получить три правильных ответа. Один скажет: 1 % от суммы на счете. Другой скажет: 100 долларов. А третий скажет: одна десятая лота. В этих ответах речь идет о разных величинах. Первые два ответа описывают денежную сумму, а третий — объем позиции, и разница между ними — не просто вопрос личных предпочтений. Эта разница определяет, что контролирует советник, а что — рынок.

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

input group "Risk Model"
input ENUM_RISK_MODE   RiskMode = RISK_PERCENT;          // How risk per trade is defined
input ENUM_RISK_BASE   RiskBase = RISK_BASE_BALANCE;     // Risk percentage measured against
input double           RiskPercent = 1.0;                // Risk per trade [%] (percent mode)
input double           FixedCashRisk = 100.0;            // Risk per trade [account currency] (cash mode)
input double           FixedLotSize = 0.10;              // Lot size (fixed-lot mode)
input double           RiskMultiplier = 1.0;             // Strategy risk factor [1.0 = unchanged]
input bool             AllowMinLotOverRisk = true;       // Trade min lot even if it exceeds intended risk

В основе этой реализации лежат два перечисления:

enum ENUM_RISK_MODE
  {
   RISK_PERCENT,        // Percentage of account
   RISK_FIXED_CASH,     // Fixed cash amount
   RISK_FIXED_LOT       // Fixed lot size
  };

enum ENUM_RISK_BASE
  {
   RISK_BASE_BALANCE,   // Account balance
   RISK_BASE_EQUITY     // Account equity
  };

Стоит ненадолго остановиться на том, почему здесь используется перечисление, а не целое число или набор булевых значений. MetaTrader отображает перечисление в виде раскрывающегося списка с заданными вами названиями, компилятор отклоняет значение, которого нет в списке, а тот, кто читает код, видит все три варианта в одном месте. При использовании bool UseFixedCash вместе с bool UseFixedLot обе переменные могли бы одновременно принимать значение true, что не имеет смысла, и коду пришлось бы определять, как трактовать такую бессмысленную комбинацию. Проверки при запуске следуют той же логике: в OnInit() проверяются только те входные параметры, которые действительно используются в выбранном режиме:

//--- Validate only the risk input the selected mode actually uses
   if(RiskMode == RISK_PERCENT && RiskPercent <= 0)
     {
      Print("Risk per trade [%] must be greater than zero in percentage mode.");
      return INIT_PARAMETERS_INCORRECT;
     }

   if(RiskMode == RISK_FIXED_CASH && FixedCashRisk <= 0)
     {
      Print("Fixed cash risk must be greater than zero in cash mode.");
      return INIT_PARAMETERS_INCORRECT;
     }

   if(RiskMode == RISK_FIXED_LOT && FixedLotSize <= 0)
     {
      Print("Fixed lot size must be greater than zero in fixed-lot mode.");
      return INIT_PARAMETERS_INCORRECT;
     }

Процент от суммы на счете

Привычный вариант. Риск составляет 1 %: при сумме на счете 10 000 долларов риск на сделку равен 100 долларам, а при сумме 20 000 долларов — 200 долларам. Торговая экспозиция растет и уменьшается вместе с суммой на счете без изменения настроек — именно этого большинство трейдеров и ожидает от системы, работающей длительное время.

Фиксированная денежная сумма

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

Фиксированный объем в лотах

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

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

Баланс или средства

Еще один входной параметр используется только в процентном режиме и определяет, от какой величины рассчитывается процент. Баланс — это сумма на счете после закрытия всех сделок. При этом не учитываются плавающая прибыль и убыток по всем открытым на данный момент позициям. Средства учитывают плавающую прибыль и убыток.

При риске в размере 1 % от средств объем следующей сделки автоматически уменьшается, если другая открытая позиция находится в убытке. Убытки усиливают осторожность. При риске в размере 1 % от баланса объем сделки остается неизменным независимо от других открытых позиций, поэтому временная просадка по открытой позиции не влияет на параметры следующей сделки. Ни один из этих подходов нельзя назвать единственно правильным. Эти подходы дают разное поведение, и понимать, какое поведение вы получаете, важнее, чем выбрать тот или иной подход. Обратите внимание: механизм снижения риска при просадке, добавленный ранее в этой серии, уже использует средства счета для оценки просадки, но по другой причине: он предназначен для выявления серии убытков, а показатель баланса вообще не отразил бы крупный плавающий убыток.

Как эти три элемента объединяются

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

//+------------------------------------------------------------------+
//| Return the monetary amount to risk on this trade                 |
//+------------------------------------------------------------------+
double GetRiskAmount()
  {
   double riskAmount = 0.0;

   if(RiskMode == RISK_FIXED_CASH)
     {
      riskAmount = FixedCashRisk;
     }
   else
     {
      //--- Balance ignores open floating P/L; equity includes it
      double riskBaseValue = (RiskBase == RISK_BASE_EQUITY)
                             ? AccountInfoDouble(ACCOUNT_EQUITY)
                             : AccountInfoDouble(ACCOUNT_BALANCE);
      riskAmount = riskBaseValue * (RiskPercent / 100.0);
     }

//--- Drawdown reduction scales the final amount
   return riskAmount * GetDrawdownRiskFactor();
  }

Раньше функция снижения риска при просадке возвращала процентное значение, что имело смысл, пока процентная модель была единственной моделью риска. Теперь эта функция возвращает обычный множитель — либо 1.0, либо коэффициент снижения, — поэтому одно и то же правило снижения риска при просадке применяется независимо от выбранного режима. Для тех, кто обновляет собственный советник: в процентном режиме, при выборе баланса в качестве базы расчета риска и отключенном снижении риска при просадке результат будет в точности таким же, как в предыдущей версии. Само правило снижения риска при просадке работает по-прежнему; изменилось лишь возвращаемое значение:

//+------------------------------------------------------------------+
//| Return the drawdown-based risk factor [1.0 = no reduction].      |
//+------------------------------------------------------------------+
double GetDrawdownRiskFactor()
  {
   if(!EnableAdaptiveRisk)
      return 1.0;

   double equity = AccountInfoDouble(ACCOUNT_EQUITY);

//--- Initialize or update the peak
   if(g_PeakEquity == 0.0 || equity > g_PeakEquity)
      g_PeakEquity = equity;

//--- Calculate current drawdown from peak
   double drawdownPercent = 0.0;
   if(g_PeakEquity > 0.0)
      drawdownPercent = (g_PeakEquity - equity) / g_PeakEquity * 100.0;

   if(drawdownPercent >= DDLevel)
     {
      PrintFormat("Adaptive Risk | Drawdown: %.2f%% >= %.2f%% | Risk scaled by %.2f",
                  drawdownPercent, DDLevel, RiskReductionFactor);
      return RiskReductionFactor;
     }

   return 1.0;
  }

Для режима фиксированного объема в лотах предусмотрена отдельная настройка реакции на просадку: оба подхода — «фиксированное значит фиксированное» и «безопасность превыше всего» — обоснованны, и код не должен делать выбор за пользователя. По умолчанию ApplyDrawdownToFixedLot отключен, поэтому фиксированный объем в лотах остается неизменным, если пользователь не укажет иное. Группа входных параметров целиком:

input group "Adaptive Risk (Drawdown)"
input bool             EnableAdaptiveRisk  = false;      // Reduce risk during drawdowns
input double           DDLevel             = 3.0;        // Drawdown % that triggers reduced risk
input double           RiskReductionFactor = 0.5;        // Adaptive risk multiplier when triggered [0.5 = half risk]
input bool             ApplyDrawdownToFixedLot = false;  // Also shrink the fixed lot during drawdowns


Где возникают ошибки при расчете объема позиции

Брокеры принимают только объемы, кратные заданному шагу объема. Результат расчета, равный 0.137 лота, должен быть приведен к значению, которое принимает брокер, — как правило, 0.13 или 0.14 с шагом 0.01. Округление до ближайшего шага кажется очевидным решением, но в нем кроется неочевидная ошибка. В половине случаев округление происходит в большую сторону, а это означает, что риск по позиции оказывается чуть выше, чем вы планировали. Это небольшая ошибка, но у нее есть направленное смещение: она приводит только к превышению запланированного риска и возникает примерно в половине всех сделок. Округление вниз не может привести к такому результату. Риск по сделке оказывается чуть ниже заданного, а отклонение в эту сторону безвредно. Теперь советник выполняет округление вниз.

На первый взгляд, для округления вниз достаточно одной строки кода:

result = MathFloor(volume / lotStep) * lotStep;

Эта строка содержит ошибку, причем такую, которую большинство тестов не выявляет. В двоичном формате с плавающей запятой невозможно точно представить число 0.01. Если разделить 0.30 на 0.01, то в результате может получиться 29.999999999999996, а не 30. Функция MathFloor() округляет это значение вниз до 29, и советник открывает позицию объемом 0.29 лота, хотя все этапы расчета, давшие это число, указывали на 0.30.

Возникновение ошибки зависит от конкретного значения, и именно этим она опасна. Попробуйте значение 0.25 — все работает. Попробуйте значение 0.30 — уже не работает. В коде нет ничего подозрительного, потому что в коде и вправду нет ничего подозрительного. Арифметика верна, а представление числа — нет.

Решение — устранить погрешность в количестве шагов перед округлением вниз:

//+------------------------------------------------------------------+
//| Round a volume DOWN to the broker's volume step.                 |
//+------------------------------------------------------------------+
double FloorToVolumeStep(double volume, double lotStep)
  {
   if(lotStep <= 0)
      return volume;

   double steps  = NormalizeDouble(volume / lotStep, 8);
   double result = MathFloor(steps) * lotStep;

//--- Match the step's own precision so the value sent to the broker is clean
   int stepDigits = (int)MathMax(0, MathCeil(-MathLog10(lotStep)));
   return NormalizeDouble(result, stepDigits);
  }

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

Когда минимальный лот требует превышения заданного риска

Именно последний случай приводит к денежным потерям на небольших счетах. Предположим, что объем, соответствующий заданному риску, составляет 0.004 лота, а минимальный объем у брокера — 0.01 лота. Совершить сделку с заданным риском невозможно. Единственный допустимый для торговли объем более чем вдвое превышает расчетный. В более ранних версиях этот советник без предупреждения повышал объем до минимального и совершал сделку. Это оправданное поведение по умолчанию, и здесь оно сохранено, поскольку полный отказ от торговли — тоже своего рода неудача. Но делать это без предупреждения неоправданно. Трейдер считает, что рискует 1 % средств счета, а фактический риск составляет 2.5 %, и нигде об этом не сообщается.

   if(lotSize < minLot)
     {
      if(!AllowMinLotOverRisk)
        {
         PrintFormat("Risk-correct volume (%.4f) is below the minimum lot (%.2f). Trade skipped to avoid over-risking.",
                     rawLot, minLot);
         return 0.0;
        }

      PrintFormat("Caution: risk-correct volume (%.4f) is below the minimum lot (%.2f). Trading %.2f - actual risk will EXCEED the intended amount.",
                  rawLot, minLot, minLot);
      lotSize = minLot;
     }

Два варианта поведения — один входной параметр. Оставьте параметр AllowMinLotOverRisk включенным, и сделка будет совершена с минимальным объемом, а предупреждение ясно сообщит о превышении заданного риска. Отключите этот параметр, и советник пропустит сделку, чтобы не превысить заданный вами риск. Выбор подходящего значения по умолчанию зависит от торгового счета. На счете с 500 долларами при заданном риске 0.5 % это предупреждение может появляться при большинстве сделок и действительно показывает, насколько настройки подходят для такого счета. На более крупном счете это предупреждение будет появляться редко.

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

//+------------------------------------------------------------------+
//| Calculate lot size for the given stop distance and risk amount.  |
//+------------------------------------------------------------------+
double CalculateLotSize(double stopDistance, double riskAmount)
  {
   double minLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);

   if(minLot <= 0 || lotStep <= 0)
     {
      Print("Invalid broker volume specification. Cannot calculate lot size.");
      return 0.0;
     }

   double rawLot = 0.0;

   if(RiskMode == RISK_FIXED_LOT)
     {
      //--- The trader dictates the volume; risk becomes an outcome, not an input
      rawLot = FixedLotSize;

      if(EnableAdaptiveRisk && ApplyDrawdownToFixedLot)
        {
         double ddFactor = GetDrawdownRiskFactor();
         if(ddFactor < 1.0)
           {
            PrintFormat("Fixed lot %.2f scaled by drawdown factor %.2f.", rawLot, ddFactor);
            rawLot *= ddFactor;
           }
        }
     }
   else
     {
      if(stopDistance <= 0)
        {
         Print("Stop distance is zero. Cannot calculate lot size.");
         return 0.0;
        }

      double tickSize  = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
      double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);

      if(tickSize <= 0 || tickValue <= 0)
        {
         Print("Invalid tick size or tick value. Cannot calculate lot size.");
         return 0.0;
        }

      double monetaryRiskPerLot = (stopDistance / tickSize) * tickValue;
      if(monetaryRiskPerLot <= 0)
        {
         Print("Monetary risk per lot is zero. Cannot calculate lot size.");
         return 0.0;
        }

      if(riskAmount <= 0)
        {
         Print("Risk amount is zero. Cannot calculate lot size.");
         return 0.0;
        }

      rawLot = riskAmount / monetaryRiskPerLot;
     }

//--- Round down to the broker's volume step
   double lotSize = FloorToVolumeStep(rawLot, lotStep);

   if(lotSize > maxLot)
      lotSize = FloorToVolumeStep(maxLot, lotStep);

//--- Below the minimum tradable volume the intended risk is unreachable
   if(lotSize < minLot)
     {
      if(!AllowMinLotOverRisk)
        {
         PrintFormat("Risk-correct volume (%.4f) is below the minimum lot (%.2f). Trade skipped to avoid over-risking.",
                     rawLot, minLot);
         return 0.0;
        }

      PrintFormat("Caution: risk-correct volume (%.4f) is below the minimum lot (%.2f). Trading %.2f - actual risk will EXCEED the intended amount.",
                  rawLot, minLot, minLot);
      lotSize = minLot;
     }

   return lotSize;
  }

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

Журнал расчета объема, соответствующего заданному риску

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

Объем, соответствующий заданному риску: сделка пропущена — записи в журнале


Второе допущение: сделка заключается прямо сейчас

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

Три способа реагировать на один и тот же сигнал

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

Режимы входа

Для сделок на продажу все зеркально. Логика пересечения осталась без изменений. Меняется то, что делает советник при появлении пересечения.

Рыночный ордер реагирует на сигнал немедленно и принимает текущую цену. Он всегда исполняется. Какова бы ни была ценность сигнала, вы получаете все, что он дает, включая любое проскальзывание.

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

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

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

Для настройки всей этой функциональности достаточно четырех входных параметров:

input group "Order Execution"
input ENUM_ENTRY_MODE  EntryMode = ENTRY_MARKET;         // Order type used to enter
input ENUM_OFFSET_MODE PendingOffsetMode = OFFSET_ATR;   // How the pending entry offset is measured
input double           PendingOffsetATR = 0.5;           // Pending offset as ATR multiple (ATR mode)
input int              PendingOffsetPoints = 150;        // Pending offset in points (points mode)
input int              PendingExpiryBars = 10;           // Delete untriggered pending after N bars [0 = never]

Смещение отложенного входа — это расстояние от текущей рыночной цены до цены отложенного входа; его можно измерить двумя способами. Смещение на основе ATR изменяется пропорционально волатильности, как и уже используемое расстояние до стоп-лосса, поэтому одна и та же настройка остается уместной и на спокойном, и на активном рынке. Фиксированное смещение в пунктах предсказуемо и понятно, но требует настройки для каждого инструмента и таймфрейма. Поддерживаются оба подхода, поскольку каждый из них обоснован, а в советнике, предназначенном для других трейдеров, лучше предусмотреть оба, чем выбирать один за читателя.

Оба выбора задаются перечислениями; одна небольшая функция преобразует выбранный вариант в расстояние, а проверки при запуске учитывают эти входные параметры только тогда, когда действительно выбран отложенный вход:

enum ENUM_ENTRY_MODE
  {
   ENTRY_MARKET,        // Market order (immediate)
   ENTRY_LIMIT,         // Pending limit (pullback entry)
   ENTRY_STOP           // Pending stop (breakout entry)
  };

enum ENUM_OFFSET_MODE
  {
   OFFSET_ATR,          // ATR-based offset
   OFFSET_POINTS        // Fixed points offset
  };

Функция:

//+------------------------------------------------------------------+
//| Resolve the concrete order type from direction and entry mode    |
//+------------------------------------------------------------------+
ENUM_ORDER_TYPE ResolveOrderType(int direction)
  {
   if(direction == 1)
     {
      switch(EntryMode)
        {
         case ENTRY_LIMIT:
            return ORDER_TYPE_BUY_LIMIT;
         case ENTRY_STOP:
            return ORDER_TYPE_BUY_STOP;
         default:
            return ORDER_TYPE_BUY;
        }
     }
   switch(EntryMode)
     {
      case ENTRY_LIMIT:
         return ORDER_TYPE_SELL_LIMIT;
      case ENTRY_STOP:
         return ORDER_TYPE_SELL_STOP;
      default:
         return ORDER_TYPE_SELL;
     }
  }

После этого направление и режим входа легко сопоставить с конкретным типом ордера. Сигнал на покупку в режиме стоп-ордера соответствует Buy Stop, сигнал на продажу в режиме лимитного ордера — Sell Limit, и так далее для всех шести комбинаций. Разместите это сопоставление в одной функции. Вся дальнейшая логика ветвится в зависимости от полученного типа ордера, поэтому определять его следует только в одном месте.


Запланированная цена входа в сделку

Как только тип ордера определен, на его основе определяется цена входа.

//+------------------------------------------------------------------+
//| The price this trade actually intends to enter at.               |
//+------------------------------------------------------------------+
double ResolveEntryPrice(ENUM_ORDER_TYPE orderType, double atrValue, const MqlTick &tick)
  {
   double offset = GetPendingOffset(atrValue);

   switch(orderType)
     {
      //--- Buys are filled at Ask, sells at Bid
      case ORDER_TYPE_BUY:
         return tick.ask;
      case ORDER_TYPE_SELL:
         return tick.bid;

      //--- Limit orders wait for a better price than the market offers now
      case ORDER_TYPE_BUY_LIMIT:
         return tick.ask - offset;
      case ORDER_TYPE_SELL_LIMIT:
         return tick.bid + offset;

      //--- Stop orders wait for the market to move further in the signal's direction
      case ORDER_TYPE_BUY_STOP:
         return tick.ask + offset;
      case ORDER_TYPE_SELL_STOP:
         return tick.bid - offset;
     }
   return 0.0;
  }

Первые два случая отражают правило, которое большинство трейдеров уже знают: ордер на покупку исполняется по цене «Ask», а ордер на продажу — по цене «Bid». В остальных четырех случаях за основу берется та же цена, от которой затем отсчитывается заданное смещение. Цена входа для лимитного ордера на покупку отсчитывается вниз от Ask, а не от Bid, поскольку Ask — это цена, по которой покупка была бы фактически исполнена прямо сейчас, а смещение должно означать «дешевле этой цены».

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

Поправка: при расчете расстояния до стоп-лосса нужно учитывать спред

Во всех предыдущих частях этой серии минимальное допустимое брокером расстояние до стоп-лосса рассчитывалось следующим образом:

minStopDistance = SYMBOL_TRADE_STOPS_LEVEL * _Point;

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

Расстояние до стоп-лосса и спред

Рассмотрим покупку. Сделка открывается по цене «Ask». После открытия позиции ее стоп-лосс срабатывает по цене Bid. Поэтому брокер измеряет расстояние до стоп-лосса от Bid, а не от цены, по которой вы купили.

Итак, брокер предъявляет следующие требования:

bid - stopLoss >= stopsLevel

А стоп-лосс размещается на уровне:

stopLoss = ask - stopDistance

Подставим одно выражение в другое:

bid - (ask - stopDistance) >= stopsLevel
stopDistance >= stopsLevel + (ask - bid)
stopDistance >= stopsLevel + spread

Применение той же алгебры к операции продажи дает тот же результат. Фактическое минимальное расстояние равно уровню стопов плюс текущий спред — именно это значение теперь использует советник:

//+------------------------------------------------------------------+
//| Smallest stop distance the broker will accept, measured from     |
//| the entry price.                                                 |
//+------------------------------------------------------------------+
double GetMinStopDistance(const MqlTick &tick)
  {
   double stopsLevel = (double)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) * _Point;
   double spread     = tick.ask - tick.bid;

   if(spread < 0)
      spread = 0;

   return stopsLevel + spread;
  }

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

Одно ограничение: здесь используется текущий спред, а не тот, который будет действовать на момент исполнения отложенного ордера. Если ордер ожидает исполнения несколько часов, эти значения могут различаться. Это разумное приближение, а не гарантия, и в большинстве случаев оно дает запас безопасности, поскольку лишь увеличивает требуемое расстояние.


Отложенные ордера должны размещаться на достаточном расстоянии

Брокеры также устанавливают минимальное расстояние между ценой отложенного ордера и текущей рыночной ценой. Разместите ордер Buy Stop на два пункта выше Ask — и сервер его отклонит. От какой стороны котировки измерять расстояние, зависит от типа ордера; если выбрать неверное направление, проверка пройдет успешно там, где должна завершиться отказом:

Тип ордера Расположение цены входа Расстояние измеряется как
Buy Limit ниже рыночной цены Ask - цена входа
Sell Limit выше рыночной цены цена входа - Bid
Buy Stop выше рыночной цены цена входа - Ask
Sell Stop ниже рыночной цены Bid - цена входа

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

//+------------------------------------------------------------------+
//| A pending entry must sit far enough from the current price       |
//+------------------------------------------------------------------+
bool IsPendingDistanceValid(const STradePlan &plan, const MqlTick &tick)
  {
   double stopsLevel = (double)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) * _Point;
   double distance   = 0.0;

   switch(plan.orderType)
     {
      case ORDER_TYPE_BUY_LIMIT:
         distance = tick.ask - plan.entryPrice;
         break;
      case ORDER_TYPE_SELL_LIMIT:
         distance = plan.entryPrice - tick.bid;
         break;
      case ORDER_TYPE_BUY_STOP:
         distance = plan.entryPrice - tick.ask;
         break;
      case ORDER_TYPE_SELL_STOP:
         distance = tick.bid - plan.entryPrice;
         break;
      default:
         return true;
     }
   if(distance < stopsLevel)
     {
      PrintFormat("Pending entry sits %.1f points from market, broker minimum is %.1f. Trade skipped.",
                  distance / _Point, stopsLevel / _Point);
      return false;
     }
   return true;
  }


Сколько на самом деле стоит отложенный ордер

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

Существующий защитный механизм незаметно перестал работать

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

   if(AllowHedging)
     {
      if(CountOpenPositionsByDirection(plan.direction) > 0 ||
         CountPendingOrdersByDirection(plan.direction) > 0)
         return false;
     }
   else
     {
      if(CountOpenPositions() > 0 || CountPendingOrders() > 0)
         return false;
     }

Функции подсчета, на которых основана эта проверка, и небольшая вспомогательная функция, определяющая направление для любого типа ордера:

//+------------------------------------------------------------------+
//| Translate any order type into its trade direction                |
//+------------------------------------------------------------------+
int OrderTypeDirection(ENUM_ORDER_TYPE orderType)
  {
   switch(orderType)
     {
      case ORDER_TYPE_BUY:
      case ORDER_TYPE_BUY_LIMIT:
      case ORDER_TYPE_BUY_STOP:
      case ORDER_TYPE_BUY_STOP_LIMIT:
         return 1;
      case ORDER_TYPE_SELL:
      case ORDER_TYPE_SELL_LIMIT:
      case ORDER_TYPE_SELL_STOP:
      case ORDER_TYPE_SELL_STOP_LIMIT:
         return -1;
     }
   return 0;
  }

//+------------------------------------------------------------------+
//| Count this EA's pending orders on the current symbol             |
//+------------------------------------------------------------------+
int CountPendingOrders()
  {
   int count = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      ulong ticket = OrderGetTicket(i);
      if(ticket == 0)
         continue;
      if(OrderGetString(ORDER_SYMBOL) == _Symbol &&
         OrderGetInteger(ORDER_MAGIC) == MagicNumber)
        {
         count++;
        }
     }
   return count;
  }

//+------------------------------------------------------------------+
//| Count this EA's pending orders in one direction                  |
//+------------------------------------------------------------------+
int CountPendingOrdersByDirection(int direction)
  {
   int count = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      ulong ticket = OrderGetTicket(i);
      if(ticket == 0)
         continue;
      if(OrderGetString(ORDER_SYMBOL) != _Symbol ||
         OrderGetInteger(ORDER_MAGIC) != MagicNumber)
         continue;

      ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
      if(OrderTypeDirection(orderType) == direction)
         count++;
     }
   return count;
  }

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

Сигналы теряют актуальность, а ордера — нет

Отложенный ордер, размещенный по сигналу пересечения, имеет смысл лишь до тех пор, пока исходные условия в целом сохраняются. Если ничего не предпринимать, он будет ждать исполнения неограниченно долго. Ордер Buy Stop, размещенный по сигналу трехдневной давности, может сработать в совершенно иной рыночной ситуации, и открытая по нему сделка уже не будет связана с исходным обоснованием входа. Теперь советник удаляет свои неисполненные отложенные ордера по истечении заданного числа баров. Проверка выполняется один раз при появлении каждого нового бара, до обработки любых сигналов, поэтому удаление устаревших ордеров происходит независимо от наличия новых сигналов:
//+------------------------------------------------------------------+
//| Delete this EA's pending orders that never triggered.            |
//+------------------------------------------------------------------+
void ManagePendingOrders()
  {
   if(PendingExpiryBars <= 0)
      return;

   int barSeconds = PeriodSeconds(_Period);
   if(barSeconds <= 0)
      return;

   datetime now = TimeCurrent();

   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      ulong ticket = OrderGetTicket(i);
      if(ticket == 0)
         continue;
      if(OrderGetString(ORDER_SYMBOL) != _Symbol ||
         OrderGetInteger(ORDER_MAGIC) != MagicNumber)
         continue;

      datetime setupTime = (datetime)OrderGetInteger(ORDER_TIME_SETUP);
      if(setupTime <= 0 || now <= setupTime)
         continue;

      int barsElapsed = (int)((now - setupTime) / barSeconds);
      if(barsElapsed < PendingExpiryBars)
         continue;

      if(trade.OrderDelete(ticket))
         PrintFormat("Pending order #%I64u expired after %d bars (limit %d). Deleted.",
                     ticket, barsElapsed, PendingExpiryBars);
      else
         PrintFormat("Failed to delete expired pending order #%I64u. Retcode: %u (%s)",
                     ticket, trade.ResultRetcode(), trade.ResultRetcodeDescription());
     }
  }

MetaTrader позволяет удалять ордера по истечении срока действия на стороне сервера, и на первый взгляд это кажется более аккуратным решением. Здесь этот вариант не выбран по практической причине: поддержка задания конкретного времени истечения срока действия зависит от брокера и инструмента, поэтому советник, который на нее полагается, на одних счетах работает, а на других молча бездействует. Проверка, которую советник выполняет самостоятельно, работает везде. Если установить входной параметр срока действия равным нулю, эта функция отключается, и ордера остаются активными.


Планирование — проверка — исполнение

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

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

Они взаимодействуют через единую структуру, которую стоит показать, поскольку она представляет собой интерфейс между этапами:

//+------------------------------------------------------------------+
//| A fully-specified trade before anything is sent to the broker.   |
//+------------------------------------------------------------------+
struct STradePlan
  {
   int               direction;      // 1 = Buy, -1 = Sell
   ENUM_ORDER_TYPE   orderType;      // Concrete order type being sent
   bool              isPending;      // True for limit/stop entries
   double            entryPrice;     // Intended entry, not necessarily current price
   double            stopLoss;
   double            takeProfit;
   double            stopDistance;   // Derived from entryPrice and stopLoss
   double            lotSize;
   double            riskAmount;     // Intended monetary risk (0 in fixed-lot mode)
  };

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

//--- Housekeeping runs every new bar, whether or not a signal appears
   ManagePendingOrders();

//--- Identify the signal on the latest closed bar (index 1)
   int direction = 0;
   if(fast[1] > slow[1] && fast[2] <= slow[2])
      direction = 1;
   else
      if(fast[1] < slow[1] && fast[2] >= slow[2])
         direction = -1;

   if(direction == 0)
      return;

//--- Plan, validate, then execute
   STradePlan plan;
   if(!BuildTradePlan(direction, atrValue, tick, plan))
      return;

   if(!ValidateTradePlan(plan, tick))
      return;

   ExecuteTradePlan(plan);
  }

Стоит остановиться на двух деталях.

Функция расчета объема позиции теперь действительно независима. Она принимает расстояние до стоп-лосса и сумму риска и возвращает объем. Она не знает, для чего рассчитывает объем — для рыночного ордера или для Sell Stop, — и ей это знать незачем. Речь не просто о том, чтобы разнести их по разным функциям — это уже было сделано, — а о том, чтобы организовать код так, чтобы ни одна из этих частей не нуждалась в сведениях о другой. Если функция не зависит от логики исполнения, изменения в этой логике не могут нарушить ее работу.

Объем рассчитывается по фактическому расстоянию от цены входа до стоп-лосса. На этапе планирования, после округления цены входа и цены стоп-лосса до числа знаков после запятой, принятого для инструмента:

   plan.stopDistance = MathAbs(plan.entryPrice - plan.stopLoss);

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

//+------------------------------------------------------------------+
//| Build a complete trade plan: intended entry, stops, and volume.  |
//+------------------------------------------------------------------+
bool BuildTradePlan(int direction, double atrValue, const MqlTick &tick, STradePlan &plan)
  {
   ZeroMemory(plan);

   plan.direction = direction;
   plan.orderType = ResolveOrderType(direction);
   plan.isPending = (EntryMode != ENTRY_MARKET);

   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);

//--- Everything below is anchored to the intended entry
   plan.entryPrice = ResolveEntryPrice(plan.orderType, atrValue, tick);
   if(plan.entryPrice <= 0)
     {
      Print("Failed to resolve an entry price. Trade skipped.");
      return false;
     }
   plan.entryPrice = NormalizeDouble(plan.entryPrice, digits);

//--- Volatility-based stop distance, widened if the broker demands it
   double stopDistance = atrValue * ATRMultiplier;
   double minStop      = GetMinStopDistance(tick);

   if(stopDistance < minStop)
     {
      PrintFormat("Stop distance %.1f points is below the broker minimum %.1f (stops level + spread). Widening.",
                  stopDistance / _Point, minStop / _Point);
      stopDistance = minStop;
     }

//--- Stops and targets measured from the intended entry
   if(direction == 1)
     {
      plan.stopLoss   = NormalizeDouble(plan.entryPrice - stopDistance, digits);
      plan.takeProfit = NormalizeDouble(plan.entryPrice + (stopDistance * TPRatio), digits);
     }
   else
     {
      plan.stopLoss   = NormalizeDouble(plan.entryPrice + stopDistance, digits);
      plan.takeProfit = NormalizeDouble(plan.entryPrice - (stopDistance * TPRatio), digits);
     }

//--- Re-derive the sizing distance from the plan's own entry and stop.
   plan.stopDistance = MathAbs(plan.entryPrice - plan.stopLoss);
   if(plan.stopDistance <= 0)
     {
      Print("Entry and stop resolved to the same price. Trade skipped.");
      return false;
     }

//--- Resolved once here, then handed to the sizing function
   plan.riskAmount = (RiskMode == RISK_FIXED_LOT) ? 0.0 : GetRiskAmount();
   plan.lotSize    = CalculateLotSize(plan.stopDistance, plan.riskAmount);

   if(plan.lotSize <= 0)
     {
      Print("Position sizing produced no tradable volume. Trade skipped.");
      return false;
     }

   return true;
  }

Проверка маржи осуществляется по тому же принципу. Маржа для отложенного ордера рассчитывается как для рыночного ордера, в который он превратится, по запланированной цене исполнения, а не по текущей цене. Это осознанно выбранная расчетная модель, а не точная величина; резервируется ли маржа до срабатывания отложенного ордера, зависит от брокера. Однако такой расчет надежно отвечает на вопрос, достаточно ли на счете средств для удержания позиции, которая возникнет после исполнения ордера. Код этапа проверки вместе со вспомогательной функцией, которая сопоставляет типу отложенного ордера соответствующий тип рыночного ордера, выглядит так:

//+------------------------------------------------------------------+
//| Reduce any order type to the market order it becomes once filled |
//+------------------------------------------------------------------+
ENUM_ORDER_TYPE MarketOrderTypeOf(ENUM_ORDER_TYPE orderType)
  {
   return (OrderTypeDirection(orderType) == 1) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
  }

//+------------------------------------------------------------------+
//| Final pre-trade validation gate.                                 |
//+------------------------------------------------------------------+
bool ValidateTradePlan(STradePlan &plan, const MqlTick &tick)
  {
//--- Exposure awareness now covers pending orders too.
   if(AllowHedging)
     {
      if(CountOpenPositionsByDirection(plan.direction) > 0 ||
         CountPendingOrdersByDirection(plan.direction) > 0)
         return false;
     }
   else
     {
      if(CountOpenPositions() > 0 || CountPendingOrders() > 0)
         return false;
     }

//--- A pending entry too close to market is rejected by the server
   if(plan.isPending && !IsPendingDistanceValid(plan, tick))
      return false;

//--- Margin is priced for the position this order will become
   double marginCheckedLot = ValidateMarginForLot(MarketOrderTypeOf(plan.orderType),
                             plan.lotSize,
                             plan.entryPrice);
   if(marginCheckedLot <= 0)
     {
      Print("Trade skipped: insufficient free margin to safely open a position.");
      return false;
     }

   plan.lotSize = marginCheckedLot;
   return true;
  }

А вот код этапа исполнения, который не принимает никаких решений, а лишь преобразует готовый план в торговый запрос:

//+------------------------------------------------------------------+
//| Send the validated plan to the broker.                           |
//+------------------------------------------------------------------+
bool ExecuteTradePlan(const STradePlan &plan)
  {
   string comment = (plan.direction == 1) ? "MA Cross Buy" : "MA Cross Sell";
   bool   sent    = false;

   switch(plan.orderType)
     {
      case ORDER_TYPE_BUY:
         sent = trade.Buy(plan.lotSize, _Symbol, 0.0, plan.stopLoss, plan.takeProfit, comment);
         break;
      case ORDER_TYPE_SELL:
         sent = trade.Sell(plan.lotSize, _Symbol, 0.0, plan.stopLoss, plan.takeProfit, comment);
         break;
      case ORDER_TYPE_BUY_LIMIT:
         sent = trade.BuyLimit(plan.lotSize, plan.entryPrice, _Symbol, plan.stopLoss, plan.takeProfit,
                               ORDER_TIME_GTC, 0, comment);
         break;
      case ORDER_TYPE_SELL_LIMIT:
         sent = trade.SellLimit(plan.lotSize, plan.entryPrice, _Symbol, plan.stopLoss, plan.takeProfit,
                                ORDER_TIME_GTC, 0, comment);
         break;
      case ORDER_TYPE_BUY_STOP:
         sent = trade.BuyStop(plan.lotSize, plan.entryPrice, _Symbol, plan.stopLoss, plan.takeProfit,
                              ORDER_TIME_GTC, 0, comment);
         break;
      case ORDER_TYPE_SELL_STOP:
         sent = trade.SellStop(plan.lotSize, plan.entryPrice, _Symbol, plan.stopLoss, plan.takeProfit,
                               ORDER_TIME_GTC, 0, comment);
         break;
      default:
         Print("Unsupported order type in trade plan. Nothing sent.");
         return false;
     }

   if(!sent)
     {
      PrintFormat("%s failed. Retcode: %u (%s)",
                  EnumToString(plan.orderType), trade.ResultRetcode(), trade.ResultRetcodeDescription());
      return false;
     }

   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);

//--- Fixed-lot mode has no intended risk to report; printing 0.00 there
   string riskText = (plan.riskAmount > 0.0)
                     ? StringFormat("%.2f", plan.riskAmount)
                     : "n/a (fixed lot)";

   PrintFormat("%s placed | Lot: %.2f | Entry: %.*f | SL: %.*f | TP: %.*f | Stop: %.1f pts",
               EnumToString(plan.orderType), plan.lotSize,
               digits, plan.entryPrice, digits, plan.stopLoss, digits, plan.takeProfit,
               plan.stopDistance / _Point);
   PrintFormat("Intended risk: %s", riskText);

   return true;
  }


Проверка

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

Тест 1 — размещение отложенного ордера и истечение срока действия ордера

Мы настроили вход через стоп-ордер, выбрав достаточно большое смещение отложенного входа, чтобы ордер не сработал слишком быстро, и короткий срок действия — 5 баров.

Истечение срока действия отложенного ордера — входные параметры

Журналы:

Истечение срока действия отложенного ордера — журналы

Тест 2 — сравнение фиксированного денежного риска и процентного риска

Тестирование за один и тот же период проводилось дважды: один раз в процентном режиме и один раз в режиме фиксированного денежного риска при сопоставимых суммах риска.

Процентный режим

В процентном режиме видно, что при просадке счета заданный риск меняется, составляя ровно 1 % от баланса счета. В режиме фиксированного денежного риска мы видим другую картину.

Режим фиксированного денежного риска

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


Несколько слов обо всех этих входных параметрах

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

  • Структурные решения принимаются один раз, исходя из того, как вы на самом деле торгуете. Модель риска, база расчета риска, режим входа и разрешение на хеджирование. Эти настройки не предназначены для оптимизации. Выбрать фиксированный денежный риск вместо процентного, потому что он соответствует вашему подходу к управлению счетом, — это осознанное решение. Выбирать его потому, что он показал лучшие результаты при тестировании на исторических данных по одному инструменту, — ошибка.
  • Защитные ограничения — это верхний предел маржи, верхний предел спреда и порог просадки. Эти параметры следует установить с запасом, а затем больше не трогать. Оптимизация защитного ограничения ради прибыли лишает его смысла.
  • Собственно параметры — это немногочисленные оставшиеся настройки: периоды скользящих средних, множитель ATR, коэффициент тейк-профита и смещение отложенного входа. Только их и стоит оптимизировать — по несколько за раз, а результат всегда следует проверять на данных, которые не использовались при оптимизации.

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


Чего эта часть не делает

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


Заключение

Мы устранили два неявных значения по умолчанию и переработали советник так, чтобы торговые намерения были явно заданы и поддавались проверке. Основные изменения:

  • Три модели риска: процент от баланса или средств, фиксированный денежный риск и фиксированный объем в лотах (с возможностью уменьшения объема при просадке).
  • Режимы входа: рыночный, лимитный и стоп-вход — со смещением отложенного входа (по ATR или на фиксированное число пунктов), истечением срока действия отложенного ордера и проверкой расстояния до цены отложенного входа.
  • Расчет объема позиции и округление: рассчитанный объем округляется ВНИЗ до допустимого шага объема брокера, учитываются минимальный и максимальный объемы в лотах; если использование минимального объема привело бы к превышению заданного риска, выдается предупреждение или сделка пропускается.
  • Стоп-лоссы: минимальное расстояние до стоп-лосса теперь включает текущий спред (уровень стопов + спред).
  • Проверки торговой экспозиции теперь учитывают и отложенные ордера.
  • Архитектура: планирование → проверка → исполнение; между этапами передается единая структура STradePlan, чтобы расчет объема позиции и исполнение не могли незаметно нарушить результаты работы друг друга.

Контрольный список для проверки (на что следует обратить внимание в журналах/результатах тестирования):

  • Сообщения об истечении срока действия отложенных ордеров и их удаление при установке параметра PendingExpiryBars.
  • Сообщение «Внимание: объем, соответствующий заданному риску, … ниже минимального объема в лотах» или сообщение о пропуске сделки, если параметр AllowMinLotOverRisk отключен.
  • Выводимая в журнал сумма риска ( заданная в процентах или в виде фиксированного денежного риска) соответствует выбранным значениям RiskMode и RiskBase.
  • Сообщения о недопустимом расстоянии до отложенного ордера и об увеличении расстояния до стоп-лосса, когда этого требуют ограничения брокера.
  • Не отправляются ордера, нарушающие правила хеджирования или ограничения на количество (при подсчете учитываются отложенные ордера).

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

Файл исходного кода советника, разработанного в этой статье, прикреплен ниже.

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

Прикрепленные файлы |
Разработка библиотеки для создания PDF-файлов на MQL5 (Часть 1): Формируем PDF-файл вручную Разработка библиотеки для создания PDF-файлов на MQL5 (Часть 1): Формируем PDF-файл вручную
В этой статье на примере двух файлов, созданных вручную, показано, как устроен PDF в виде обычного текста: страницы объемом 592 байта и тикета сделки объемом 885 байт. В статье объясняются структура файла (заголовок, тело, xref, трейлер), необходимые для страницы объекты и ресурсы, а также операторы вывода текста, после чего приводится скрипт на MQL5 для создания этих файлов. Первая часть серии статей о библиотеке для работы с PDF, написанной исключительно на MQL5.
Робастная регрессия на языке MQL5 Робастная регрессия на языке MQL5
В статье рассматривается класс робастных регрессионных моделей, устойчивых к выбросам в данных. Такие модели особенно полезны при работе с финансовыми данными, распределение которых часто отклоняется от нормального. Реализованы три подхода на языке MQL5: регрессия на основе распределения Стьюдента, регрессия Лапласа и регрессия с функцией потерь Хубера. Показаны особенности их обучения с применением численных методов оптимизации: EM-алгоритма, линейного программирования и метода L-BFGS из библиотеки ALGLIB. Проводится сравнение с методом наименьших квадратов на синтетических данных, что помогает оценить поведение моделей при наличии выбросов.
Регрессия на основе гауссовских процессов на MQL5: Краткосрочное прогнозирование цен с полосами неопределенности Регрессия на основе гауссовских процессов на MQL5: Краткосрочное прогнозирование цен с полосами неопределенности
В статье переработана модель прогнозирования на основе гауссовского процесса на чистом MQL5: входные данные характеризуют состояние рынка, а целевые переменные задаются непосредственно как логарифмические доходности за горизонт прогнозирования. В ней используются ядро Матерна 3/2, разложение Холецкого с обеспечением симметрии матрицы и адаптивной диагональной добавкой, стандартизированные целевые переменные и поиск по сетке в логарифмическом пространстве без побочного изменения состояния объекта. Советник торгует только тогда, когда z-оценка, рассчитанная с использованием дисперсии наблюдений, достигает заданного порога или превышает его, а торговое преимущество превышает текущий спред. Калибровка проверяется в тестере стратегий.
Автоматическое построение сессионного профиля объема на MQL5: Визуализация POC и зоны стоимости без сторонних инструментов Автоматическое построение сессионного профиля объема на MQL5: Визуализация POC и зоны стоимости без сторонних инструментов
Реализуйте сессионный профиль объема на MQL5: получайте тики с помощью CopyTicksRange(), группируйте их по ценовым интервалам и рассчитывайте POC, VAH и VAL по правилу 70%. Индикатор отображает профиль непосредственно на графике с помощью штатных графических объектов, поддерживает масштабирование в режиме фиксированной ширины для сохранения единообразной геометрии на разных таймфреймах и обновляется с началом каждой новой сессии. Это позволяет получить объективные опорные уровни без внешних зависимостей.