MetaTrader 5 / Примеры
preview
MetaTrader 5: конструируйте рынок под стратегию — Renko/Range/Volume, синтетика и стресс-тесты на пользовательских символах

MetaTrader 5: конструируйте рынок под стратегию — Renko/Range/Volume, синтетика и стресс-тесты на пользовательских символах

MetaTrader 5 — Примеры |
61 0
MetaQuotes
MetaQuotes

Введение

Стандартный график MetaTrader 5 — это надежный инструмент, но он жестко привязан к таймфреймам, брокерскому потоку котировок и календарной сетке. В современном алготрейдинге этого часто недостаточно: так называемый шум волатильности, пробелы в истории и фиксированные временные интервалы искажают реальную динамику. Что, если терминал позволяет не только читать рынок, но и конструировать его представление под задачи конкретной стратегии?

С развитием API пользовательских символов MetaTrader 5 изменил архитектуру: трейдер перестает быть пассивным потребителем котировок и становится архитектором данных. Пользовательский символ — это не офлайн-график для визуализации, а полноценный объект терминала с собственной тиковой историей, спецификацией контракта и нативной поддержкой в Тестере стратегий.

Теперь вы можете генерировать вне-временные графики (Ренко-бары, Рэйндж-бары, равнообъемные бары), собирать синтетические инструменты и корзины, а также проводить стресс-тесты, произвольно меняя спред, стоп-уровни и маржинальные требования прямо в коде.

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

Custom Data Flow

Рис.1: Конструируй свой рынок из стандартных материалов


Что такое пользовательский символ: архитектура, хранение и API

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

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

Пользовательские символы изолированы от торговых серверов брокера. Файлы хранятся локально, например: “AppData\Roaming\MetaQuotes\Terminal\[InstanceID]\bases\Custom”.

Такое решение имеет важное преимущество: независимость. Вы можете сменить брокера, обновить терминал, но ваши пользовательские символы и наработанная история останутся на месте. В окне «Обзор рынка» они всегда располагаются в отдельной папке «Custom», чтобы визуально разделить реальные инструменты и ваши собственные.


Ядро MQL5 API

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

Управление жизненным циклом символа:

  • CustomSymbolCreate() — создает пользовательский символ с указанным именем в указанной группе,
  • CustomSymbolDelete() — удаляет пользовательский символ с указанным именем,
  • SymbolSelect() — добавляет в Обзор рынка (без этого символ не будет виден в графическом интерфейсе).

Управление загрузкой данных:

  • CustomTicksAdd() — добавляет в ценовую историю пользовательского символа данные из массива типа MqlTick[]. Пользовательский символ должен быть выбран в окне Обзор рынка,
  • CustomTicksReplace() — полностью заменяет ценовую историю пользовательского символа в указанном временном интервале данными из массива типа MqlTick[],
  • CustomRatesUpdate() — добавляет в историю пользовательского символа отсутствующие бары и/или заменяет существующие данными из массива типа MqlRates[].

Управление свойствами:

  • CustomSymbolSetInteger()/CustomSymbolSetDouble()/CustomSymbolSetString() — настройка свойств контракта (спред, точность, валюта маржи и т.д.).


Прямой вызов API-функций требует обработки разнообразных ошибок и проверки статусов. Для ускорения разработки используем класс-обертку CiCustomSymbol. Он инкапсулирует логику создания, клонирования свойств реального символа и пакетной загрузки тиков. Полный код класса CiCustomSymbol находится в файле «CiCustomSymbol.mqh», приложенном к статье.

Пример инициализации пользовательского символа — создаем символ, клонируем свойства из символа EURUSD и проверяем коды возврата:

#include <CiCustomSymbol.mqh>

//+------------------------------------------------------------------+
//| входные параметры                                                |
//+------------------------------------------------------------------+
input string   CustomSymbolName = "EURUSD_Custom"; // имя нового символа
input string   OriginSymbol     = "EURUSD";        // исходный символ

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   CiCustomSymbol symb;
   
//--- пытаемся создать символ
//--- коды возврата: -1 (ошибка), 0 (уже существует), 1 (успешно создан)
   int res = symb.Create(CustomSymbolName, "", OriginSymbol, 1000000, true);
   
   if(res == -1)
     {
      Print("Ошибка создания символа: ", GetLastError());
      return;
     }
   
   if(res == 0)
     {
      Print("Символ ", CustomSymbolName, " уже существует.");
     }
   else
     {
      Print("Символ ", CustomSymbolName, " успешно создан.");
      
      //--- настройка специфичных свойств (например, фиксированный спред 20 пунктов)
      //--- свойства меняются ДО загрузки истории
      if(!symb.SetProperty(SYMBOL_SPREAD, 20))
         Print("Не удалось задать спред. Ошибка: ", GetLastError());
         
      if(!symb.SetProperty(SYMBOL_SPREAD_FLOAT, false))
         Print("Не удалось задать тип спреда (фиксированный). Ошибка: ", GetLastError());
     }
   
//--- символ добавлен в Обзор рынка (параметр true в Create)
   Print("Символ создан: ", CustomSymbolName);
  }

Полный код скрипта находится в файле «CreateCustomSymbol.mq5», приложенном к статье.

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

Запрет на MQL5 Cloud Network:

Оптимизация стратегий на пользовательских символах через облачную сеть запрещена. Причина проста: на компьютерах разных трейдеров могут находиться символы с одинаковыми именами (например, EURUSD_Custom), но с абсолютно разной историей. Использование Cloud Network привело бы к хаосу синхронизации и генерации избыточного трафика. Тестировать можно только локально или через локальных агентов.

Логика расчета маржи:

Тестер стратегий использует кросс-курсы для расчета залога и прибыли. Если вы создали и тестируете символ AUDCAD.custom (на базе AUDUSD/USDCAD) и ваш счет в USD, то тестеру нужно:

  • Для расчета маржи — найти AUDUSD (сколько стоит AUD в USD)
  • Для расчета прибыли — найти USDCAD (как перевести CAD обратно в USD)

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

Свойства символа не меняются во время теста:

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


Аналитическое отступление: Смысл бэктестинга

Зачем нужна такая сложная архитектура? Использование пользовательских символов меняет подход к проверке торговых идей. Вместо того чтобы подгонять стратегию под возможно кривые данные конкретного брокера (с пропусками в истории или аномальными спредами), вы конструируете свою идеальную лабораторную среду.

Вы можете проверить, как стратегия поведет себя при спреде 50 пунктов (чтобы отсеять скальпинг), или как она торгует на графиках, где время не имеет значения (Range/Renko). Это позволяет отделить суть самой стратегии от артефактов так называемого рыночного шума.

Вне-временные графики: Renko, Range Bars и Equal-Volume

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

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

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

Разберем три популярных типа таких графиков — Renko, Range Bars и Equal-Volume — и покажем, как реализовать их генерацию в MetaTrader 5 с помощью пользовательских символов. Для начала сравним и опишем эти три типа баров в виде таблицы:

Тип графика  Критерий формирования нового бара  Когда лучше использовать 
Renko Движение цены на заданное количество пунктов Трендовые стратегии, фильтрация боковиков
Range Bars Размах (High–Low) бара достигает заданного значения Скальпинг, внутридневная торговля в волатильных условиях
Equal-Volume Накопление заданного количества тиков или реального объема Анализ ликвидности, поиск зон интереса крупных игроков

Важно:

Все пользовательские символы в MetaTrader 5 привязаны к сетке таймфрейма M1. Это архитектурное ограничение платформы: даже если бар сформировался за 2 секунды, в истории он получит временную метку с точностью до минуты. При высокой волатильности несколько баров могут попасть в одну и ту же минуту (иметь одинаковое время) — эксперт должен это учитывать.


Техническая реализация: агрегация тиков в бары

В целом, алгоритм генерации вне-временных баров одинаков для всех трех типов:

  1. Чтение тиков из истории или получение онлайн через функции CopyTicksRange()/OnTick(), соответственно;
  2. Накопление данных в буфере: отслеживание Open, High, Low, Close, Volume;
  3. Проверка условия формирования нового бара (пункты/размах/объем);
  4. Запись бара в базу пользовательского символа через CustomRatesUpdate();
  5. Эмуляция тика через CustomTicksAdd() для активации индикаторов и советников на графиках MetaTrader 5.

Базовый класс для работы с пользовательскими символами: алгоритм для всех типов баров

//+------------------------------------------------------------------+
//| класс-агрегатор тиков в пользовательские бары                    |
//+------------------------------------------------------------------+
class CBarAggregator
  {
private:
   string            symbol_name;
   double            threshold;
   int               bar_type;
   ENUM_VOLUME_MODE  volume_mode;

   MqlRates          rates_buffer[];
   int               buffer_limit;
   int               buffer_idx;

   MqlRates          current_bar;
   double            last_close;
   int               trend;
   bool              is_initialized;
   datetime          last_bar_time;
   int               symbol_digits;

public:
                     CBarAggregator(void);
   bool              Init(const string _symbol_name, double _threshold, int _bar_type, ENUM_VOLUME_MODE _vol_mode = VOLUME_MODE_TICK);
   bool              ProcessTick(const MqlTick &tick);
   void              FlushBuffer(void);
   void              Reset(void);

private:
   void              CreateBar(const MqlTick &tick, double open_price = 0.0);
   void              CloseAndSaveBar(const MqlTick &tick, double forced_close = 0.0);
   void              WriteBatch(void);
  };

//+------------------------------------------------------------------+
//| обработка входящего тика                                         |
//+------------------------------------------------------------------+
bool CBarAggregator::ProcessTick(const MqlTick &tick)
  {
   if(tick.bid <= 0 || tick.ask <= 0)
      return false;
   if(tick.time <= 0)
      return false;  // защита от невалидных тиков

   if(!is_initialized)
     {
      CreateBar(tick);
      last_close = tick.bid;
      last_bar_time = tick.time;  // инициализируем временем первого тика
      is_initialized = true;
      return false;
     }

   bool bar_closed = false;

   if(bar_type == 0) // renko
     {
      double diff = tick.bid - last_close;
      double size = threshold * _Point;
      int req_move = (trend != 0) ? 2 : 1;

      if(diff >= size * req_move)
        {
         int bricks = (int)(diff / size);
         for(int i = 0; i < bricks; i++)
           {
            double target_close = NormalizeDouble(last_close + size, symbol_digits);
            CloseAndSaveBar(tick, target_close);
            last_close = target_close;
            CreateBar(tick, last_close);
            trend = 1;
           }
         bar_closed = true;
        }
      else
         if(diff <= -size * req_move)
           {
            int bricks = (int)(MathAbs(diff) / size);
            for(int i = 0; i < bricks; i++)
              {
               double target_close = NormalizeDouble(last_close - size, symbol_digits);
               CloseAndSaveBar(tick, target_close);
               last_close = target_close;
               CreateBar(tick, last_close);
               trend = -1;
              }
            bar_closed = true;
           }
     }
   else
      if(bar_type == 1) // range bars
        {
         double bid = NormalizeDouble(tick.bid, symbol_digits);
         if(bid > current_bar.high)
            current_bar.high = bid;
         if(bid < current_bar.low)
            current_bar.low = bid;

         if((current_bar.high - current_bar.low) >= threshold * _Point)
           {
            CloseAndSaveBar(tick);
            CreateBar(tick);
            bar_closed = true;
           }
        }
      else
         if(bar_type == 2) // equal volume bars
           {
            if(volume_mode == VOLUME_MODE_REAL)
               current_bar.real_volume += (long)tick.volume_real;
            else
               current_bar.tick_volume++;

            long current_vol = (volume_mode == VOLUME_MODE_REAL) ? current_bar.real_volume : current_bar.tick_volume;
            if(current_vol >= (long)threshold)
              {
               CloseAndSaveBar(tick);
               CreateBar(tick);
               bar_closed = true;
              }
           }

   return bar_closed;
  }

//+------------------------------------------------------------------+
//| закрытие бара и сохранение в буфер                               |
//+------------------------------------------------------------------+
void CBarAggregator::CloseAndSaveBar(const MqlTick &tick, double forced_close)
  {
   current_bar.close = (forced_close != 0.0) ? NormalizeDouble(forced_close, symbol_digits) : NormalizeDouble(tick.bid, symbol_digits);

   current_bar.high  = NormalizeDouble(MathMax(current_bar.high, MathMax(current_bar.open, current_bar.close)), symbol_digits);
   current_bar.low   = NormalizeDouble(MathMin(current_bar.low, MathMin(current_bar.open, current_bar.close)), symbol_digits);
   current_bar.spread = MathMax(0, current_bar.spread);

// проверяем, что last_bar_time > 0 (инициализирован)
   if(last_bar_time > 0 && current_bar.time <= last_bar_time)
     {
      // сдвигаем на 1 секунду вместо 60, чтобы минимизировать искажение
      current_bar.time = last_bar_time + 1;
     }
   last_bar_time = current_bar.time;

// финальная валидация перед буфером
   if(current_bar.high < current_bar.low ||
      current_bar.high < current_bar.open || current_bar.high < current_bar.close ||
      current_bar.low > current_bar.open || current_bar.low > current_bar.close)
     {
      Print("🟡 Пропущен ошибочный бар: O=", current_bar.open, " H=", current_bar.high, " L=", current_bar.low, " C=", current_bar.close, " Time=", TimeToString(current_bar.time));
      return;
     }

   if(buffer_idx < buffer_limit)
     {
      rates_buffer[buffer_idx] = current_bar;
      buffer_idx++;
     }

   if(buffer_idx >= buffer_limit)
      WriteBatch();
  }

//+------------------------------------------------------------------+
//| запись буфера в историю символа                                  |
//+------------------------------------------------------------------+
void CBarAggregator::WriteBatch(void)
  {
   if(buffer_idx > 0)
     {
      datetime t_from = rates_buffer[0].time;
      datetime t_to   = rates_buffer[buffer_idx - 1].time;

      if(CustomRatesUpdate(symbol_name, rates_buffer) < 1)
         Print("ошибка CustomRatesUpdate: ", GetLastError());

      buffer_idx = 0;
     }
  }
//+------------------------------------------------------------------+

Полный код класса CBarAggregator находится в файле «CBarAggregator.mqh».


Универсальный индикатор вне-временных баров

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

Входные параметры:

input ENUM_CUSTOM_CHART_MODE InputMode = CMT_RENKO;      // режим генерации
input double InputBoxSize = 10;                          // размер бара (пункты) для renko/range
input long InputVolLimit = 1000;                         // лимит объема для equal-volume
input string InputSuffix = "";                           // суффикс имени символа
input datetime InputStartTime  = 0;                      // начало истории (0 - последние 7 дней)

Перечисление режимов генерации баров:

enum ENUM_CUSTOM_CHART_MODE
  {
   CMT_RENKO = 0,       // ренко
   CMT_RANGE = 1,       // range bars
   CMT_EQVOL_TICK = 2,  // равные тиковые объемы
   CMT_EQVOL_REAL = 3   // равные реальные объемы
  };

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

//+------------------------------------------------------------------+
//| обработка нового тика                                            |
//+------------------------------------------------------------------+
void ProcessNewTicks()
  {
   if(last_tick_time_msc==0)
      return;

   MqlTick ticks[];
   int copied=CopyTicksRange(_Symbol,ticks,COPY_TICKS_ALL,last_tick_time_msc,0);

   if(copied>0)
     {
      for(int i=0;i<copied;i++)
        {
         aggregator.ProcessTick(ticks[i]);
         last_tick_time_msc=ticks[i].time_msc;
        }
      aggregator.FlushBuffer();
     }
  }

Этот индикатор не рисует графики сам. Его задача — создать и наполнить данными пользовательский символ. Для начала перетащите индикатор на любой график (например, EURUSD) — откроется окно свойств. Выберите режим (например, MODE_RENKO), размер коробки (InputBoxSize) и начало истории.

Последовательность использования индикатора:

  • Индикатор запустит процесс генерации баров (в журнале появятся сообщения о начале и завершении генерации),
  • После появления сообщения о завершении генерации откройте Обзор рынка (Ctrl+M),
  • В списке символов найдите и выберите созданный инструмент (например, EURUSD_Renko_10),
  • Откройте новый график (Ctrl+N),
  • Установите таймфрейм M1,

Результаты работы индикатора в разных режимах представлены на Рис.2 — Рис.4.

Renko

Рис.2: Ренко-бары

Range

Рис.3: Рейндж-бары

Equal Volume

Рис.4: Равнообъемные бары

Рассмотрим кратко особенности и примеры использования вне-временных баров.

Ренко — новый бар рисуется только когда цена преодолевает заданный размер бара в пунктах от цены закрытия предыдущего бара. Направление бара (бычий/медвежий) определяется направлением пробоя. Тени, по умолчанию, не отображаются, но могут при необходимости использоваться для анализа внутрибарной волатильности. При сильном движении за одну минуту может сформироваться несколько баров. Цена закрытия бара — это цена пробоя, а не цена на момент закрытия минуты.

Пример стратегии с Ренко:

  • Вход — пересечение быстрой MA(9) и медленной MA(21) на закрытии бара,
  • Фильтр — если значение ATR(14) больше заданного порога, отсеиваем ложные пробои в боковике,
  • Выход — обратное пересечение скользящих или фиксированный стоп в пунктах,
  • Особенность — торговля ведется по цене PRICE_CLOSE, так как нулевой (последний) бар ренко всегда незавершен.

Рейндж-бары — новый бар открывается, когда размах между High и Low достигает заданного значения в пунктах. В отличие от ренко, здесь учитывается все движение внутри бара, а не только закрытие. Вместо фиксированного значения размера можно использовать динамический размер бара (Range) на основе ATR.

Что означает размер Range? Размер Range задает величину порогового изменения цены, при котором начинает формироваться новый бар. 1 Range равен одному минимальному изменению цены. Это значение можно представить следующей формулой: 1 Range = Tick Size (размер тика).

Преимущества для использования в скальпинге:

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

Равнообъемные бары — новый бар создается после накопления заданного количества тиков (для Forex) или реального объема (для биржевых инструментов). Бары одинакового объема позволяют сравнивать движения на равных основаниях:

  • Зоны с быстрым формированием баров означают высокую активность, следовательно возможен пробой текущего диапазона.
  • Пустые участки графика означают отсутствие интереса, следовательно возможен разворот.

Замечание:

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

Решение данной проблемы:

  • Всегда берите сигналы с первого бара (завершенного), а не с нулевого;
  • Устанавливайте в тестере работу по закрытым барам;
  • Используйте маршрутизацию приказов на реальный символ (см. ниже) — это устранит артефакты генерации тиков в тестере.


Синтетические инструменты: спреды, корзины и межрыночные связи

Рынок редко движется изолированно — инструменты, как правило, цепляются один за другой. EURUSD тянет за собой GBPUSD, нефть диктует настроение в CAD, AUD и NOK, а индексы S&P 500 и DAX часто идут синхронно. Но что, если вместо пассивного наблюдения за корреляциями мы создадим единый инструмент, математически объединяющий эти активы? Пользовательские символы в MetaTrader 5 позволяют выйти за рамки стандартных инструментов брокера и сконструировать собственную аналитическую систему: спреды, корзины, арбитражные пары и антикорреляционные индексы.

Математика синтетики:

В основе любого синтетического инструмента лежит линейная комбинация:

Synth = k₁·Asset_A ± k₂·Asset_B ± ... ± kₙ·Asset_N.

На практике чаще всего используется упрощенная формула спреда двух активов:

Spread = Price_A - Ratio · Price_B,

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

Основная техническая задача — синхронизация тиков. Асинхронное получение котировок от разных пулов ликвидности приводит к рваным спредам и ложным пробоям. В MetaTrader 5 мы решаем это через временное окно буферизации и фиксацию последней известной цены для каждой ноги синтетики.

Генератор синтетических тиков:

//+------------------------------------------------------------------+
//| генератор синтетических тиков на основе двух активов             |
//+------------------------------------------------------------------+
class CSyntheticTickGenerator
  {
private:
   string            symbol_a;
   string            symbol_b;
   string            synth_name;
   double            ratio;
   double            last_price_a;
   double            last_price_b;
   int               symbol_digits;
   double            point;

public:
   //+------------------------------------------------------------------+
   //| инициализатор                                                    |
   //+------------------------------------------------------------------+
   bool              Init(const string _sym_a, const string _sym_b, const string _synth, double _ratio)
     {
      symbol_a=_sym_a;
      symbol_b=_sym_b;
      synth_name=_synth;
      ratio=_ratio;
      symbol_digits=(int)SymbolInfoInteger(_sym_a, SYMBOL_DIGITS);
      point=SymbolInfoDouble(_sym_a, SYMBOL_POINT);
      last_price_a=0.0;
      last_price_b=0.0;
      return true;
     }

   //+------------------------------------------------------------------+
   //| обработка прищедщего тика                                        |
   //+------------------------------------------------------------------+
   void              ProcessTick(const MqlTick &tick, const string source_symbol)
     {
      if(tick.bid<=0 || tick.ask<=0)
         return;

   //--- обновление последней известной цены для соответствующей ноги
      if(source_symbol==symbol_a)
        {
         last_price_a=tick.bid;
        }
      else
         if(source_symbol==symbol_b)
           {
            last_price_b=tick.bid;
           }

   //--- ждем появления цен по обоим активам
      if(last_price_a<=0 || last_price_b<=0)
         return;

   //--- расчет синтетической цены с нормализацией
      double synth_bid=NormalizeDouble(last_price_a-ratio*last_price_b, symbol_digits);

      double base_spread=tick.ask-tick.bid;
      double synth_ask=NormalizeDouble(synth_bid+base_spread, symbol_digits);

   //--- формирование структуры тика
      MqlTick synth_tick={0};
      synth_tick.time=tick.time;
      synth_tick.time_msc=tick.time_msc;
      synth_tick.bid=synth_bid;
      synth_tick.ask=synth_ask;
      synth_tick.flags=TICK_FLAG_BID | TICK_FLAG_ASK;

   //--- запись в базу пользовательского символа
      MqlTick batch[1];
      batch[0]=synth_tick;
      CustomTicksAdd(synth_name, batch);
     }
  };
//+------------------------------------------------------------------+


Пример стратегии — синтетические спреды идеально подходят для статистического арбитража и стратегий на основе возврата к средней. Традиционный подход — отслеживание отклонения спреда от скользящей средней в единицах стандартного отклонения (z-score).

Логика сигналов:

  • Вход — если |z-score| > 2.0, отклонение спреда статистически аномально;
  • Выход — |z-score| < 0.5, произошел возврат к среднему, закрытие позиции;
  • Управление риском — стоп-лосс привязывается к волатильности корзины (например, 2.5 × ATR(20)).

Функции для расчета z-score и формирования сигналов представлены ниже:

//+------------------------------------------------------------------+
//| расчет z-score для синтетического спреда                         |
//+------------------------------------------------------------------+
double CalculateSpreadZScore(const string synth_symbol, int ma_period, int std_dev_period)
  {
   static int ma_handle=INVALID_HANDLE;
   static int std_handle=INVALID_HANDLE;
   
//--- инициализация хэндлов при первом вызове
   if(ma_handle == INVALID_HANDLE)
     {
      ma_handle=iMA(synth_symbol, PERIOD_M1, ma_period, 0, MODE_SMA, PRICE_CLOSE);
      if(ma_handle==INVALID_HANDLE)
        {
         Print("Ошибка создания хэндла iMA: ", GetLastError());
         return 0.0;
        }
     }
   
   if(std_handle == INVALID_HANDLE)
     {
      std_handle = iStdDev(synth_symbol, PERIOD_M1, std_dev_period, 0, MODE_SMA, PRICE_CLOSE);
      if(std_handle==INVALID_HANDLE)
        {
         Print("Ошибка создания хэндла iStdDev: ", GetLastError());
         return 0.0;
        }
     }
   double ma_buf[], std_buf[], close_buf[];
   ArraySetAsSeries(ma_buf, true);
   ArraySetAsSeries(std_buf, true);
   ArraySetAsSeries(close_buf, true);
   
//--- копируем данные с 1-го завершенного бара (индекс 1, количество 1)
   if(CopyBuffer(ma_handle, 0, 1, 1, ma_buf) != 1)
      return 0.0;
   if(CopyBuffer(std_handle, 0, 1, 1, std_buf) != 1)
      return 0.0;
   if(CopyClose(synth_symbol, PERIOD_M1, 1, 1, close_buf) != 1)
      return 0.0;
   
   double spread_ma = ma_buf[0];
   double spread_std = std_buf[0];
   double current_spread = close_buf[0];
   
   if(spread_std == 0.0)
      return 0.0;
   return (current_spread - spread_ma) / spread_std;
  }

//+------------------------------------------------------------------+
//| генератор торговых сигналов                                      |
//+------------------------------------------------------------------+
int CheckSpreadSignal(const string synth_symbol)
  {
   double z = CalculateSpreadZScore(synth_symbol, 20, 20);
   if(z>2.0)
      return -1; // спред перекуплен -> шорт спреда
   if(z<-2.0)
      return 1;  // спред перепродан -> лонг спреда
   if(MathAbs(z)<0.5)
      return 0;  // сигнал на закрытие
   return 0;
  }

Направление хеджа зависит от знака z-score: при положительном отклонении продаем перекупленную ногу a и покупаем перепроданную ногу b, при отрицательном — наоборот. Маржинальные требования рассчитываются тестером автоматически, если в MarketWatch доступны соответствующие кросс-курсы.


Корзинные индексы и динамическая ребалансировка

Если спред — это инструмент из двух ног, то корзина — это портфель из N символов. Весовые коэффициенты могут быть:

  • Статическими — равновзвешенными (k = 1/N) или фиксированными по капитализации/ликвидности символа;
  • Динамическими — пересчитываемыми по обратной волатильности или скользящему объему.

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


Аналитическое отступление: подводные камни синтетики

Корреляция не равна причинности — историческая связь активов может разорваться в момент макроэкономических шоков. Синтетический спред EURUSD/GBPUSD, стабильный годами, может дать гэп в 50–80 пунктов на новостях по ставке ЦБ или геополитике. Стратегия возврата к среднему не учитывает структурные изменения в активах (символах).

Расчет маржи и прибыли в тестере — тестер стратегий автоматически ищет кросс-курсы для конвертации залога и получения финансового результата. Если вы тестируете SYNTH_EURGBP.custom на счете в USD, терминал ищет пары в следующем порядке:

  • EURUSD.custom / GBPUSD.custom (пользовательские)
  • EURUSD.b / GBPUSD.b (с суффиксом брокера)
  • EURUSD / GBPUSD (базовые пары)

При их отсутствии в Обзоре рынка тестер выдаст ошибку расчета маржи или обнулит прибыль.

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

Фильтрация новостей — статистический арбитраж на спредах сильно уязвим к асимметричным макро-событиям (когда событие затрагивает только одну страну-эмитент). Рекомендуется добавлять фильтр экономического календаря или волатильности, отключающий стратегию за 30–60 минут до выхода данных высокой важности.


Пайплайн интеграции в рабочий процесс

В разработке торговых систем на MQL5 «пайплайн интеграции» — это цепочка обработки данных и событий, связывающая внешний источник с торговым интерфейсом терминала..

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

  1. Поступают сырые тики от брокера — используются функции SymbolInfoTick() или/и история тиков CopyTicksRange(). Например, тики по EURUSD и GBPUSD приходят от различных серверов.
  2. Класс-агрегатор (CBarAggregator или CSyntheticTickGenerator) получает эти тики, синхронизирует их по времени и применяет математическую формулу. Например, вычисляет спред Price(EUR) - Price(GBP).
  3. Результат записывается в базу терминала — через функции CustomRatesUpdate() или CustomTicksAdd(). Например, создание пользовательского символа SPREAD_EURGBP.custom. Теперь терминал работает с этим инструментом также, как с обычными валютными парами.
  4. Использование стандартных средств платформы для созданного символа — запуск советника/индикатора в Тестере стратегий.


Стресс-тестирование через модифицированную историю

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

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

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

Философия стресс-теста достаточно проста — мы пробуем сломать систему до выхода на реальный рынок.

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

Сценарии модификации:

  • Расширение спреда — эмуляция скачков издержек, критичных для скальпинга и внутридневной торговли.
  • Увеличение уровней Stop Level / Freeze Level — проверка устойчивости к ограничениям брокера на установку стоп-лоссов и тейк-профитов.
  • Изменение маржинальных требований — тест на устойчивость к маржин-коллам при изменении кредитного плеча;
  • Инъекция токсичных тиков — добавление гэпов или разрывов ликвидности.

Главное преимущество подхода через пользовательские символы — воспроизводимость. Вы можете запустить один и тот же тест с разными параметрами стресса и сравнить метрики (Профит фактор, Максимальную просадку, Фактор восстановления) в табличном виде.


Сценарий 1: Искусственное расширение спреда

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

Вот пример скрипта, который создает стрессовую версию символа с фиксированным высоким спредом:

//+------------------------------------------------------------------+
//| входные параметры                                                |
//+------------------------------------------------------------------+
input string   SourceSymbol        = "EURUSD";          // Исходный символ
input string   TargetSymbol        = "EURUSD_Stress";   // Имя нового символа
input int      StressSpreadPoints  = 50;                // Фиксированный спред (в пунктах)
input datetime HistoryFromDate     = D'2023.01.01';     // Начало загрузки истории
input bool     DeleteOldData       = true;              // Очистить историю целевого символа перед записью

CiCustomSymbol stressSymb;

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   double point;
   int    digits;

//--- получаем свойства исходного символа для расчетов
   point = SymbolInfoDouble(SourceSymbol, SYMBOL_POINT);
   digits = (int)SymbolInfoInteger(SourceSymbol, SYMBOL_DIGITS);

   if(point == 0)
     {
      Print("Ошибка: не удалось получить размер пункта для ", SourceSymbol);
      return;
     }

   Print("--- Начало генерации стресс-символа ---");
   PrintFormat("Источник: %s | Цель: %s | Спред: %d пп", SourceSymbol, TargetSymbol, StressSpreadPoints);

//--- создаем пользовательский символ через метод класса
//--- коды возврата: -1 (ошибка), 0 (уже есть), 1 (создан)
   int createRes = stressSymb.Create(TargetSymbol, "", SourceSymbol, 1000000, true);

   if(createRes == -1)
     {
      Print("Ошибка создания символа через CiCustomSymbol.Create()");
      return;
     }

   stressSymb.Select(true);

//--- клонируем свойства контракта (Digits, Point, Mode и т.д.)
   if(!stressSymb.Clone(SourceSymbol))
     {
      Print("Ошибка клонирования свойств символа");
      return;
     }

//--- очистка старой истории
   if(DeleteOldData)
     {
      Print("Очистка истории через CiCustomSymbol...");
      if(stressSymb.TicksDelete(0, LONG_MAX) < 0)
         Print("Не удалось очистить тики: ", GetLastError());
     }

//--- циклическая загрузка и модификация тиков (пачками по 1 дню)
   datetime current_date = HistoryFromDate;
   datetime stop_date = TimeCurrent();

   if(current_date >= stop_date)
     {
      Print("Ошибка: дата начала истории некорректна.");
      return;
     }

   int total_ticks_added = 0;
   MqlTick ticks[];

//--- рассчитываем величину стресс-спреда
   double stress_spread_value = StressSpreadPoints * point;

   Print("Запуск пакетной обработки истории...");

   while(current_date < stop_date && !IsStopped())
     {
      //--- определяем границы дня
      datetime day_start = current_date;
      datetime day_end = current_date + PeriodSeconds(PERIOD_D1);

      ulong t1 = (ulong)day_start * 1000;
      ulong t2 = (ulong)day_end * 1000;

      //--- читаем тики исходного символа
      int copied = CopyTicksRange(SourceSymbol, ticks, COPY_TICKS_ALL, t1, t2);

      if(copied > 0)
        {
         //--- стресс-модификация данных
         for(int i = 0; i < copied; i++)
           {
            //--- устанавливаем Ask = Bid + Фиксированный Спред
            ticks[i].ask = ticks[i].bid + stress_spread_value;

            //--- помечаем, что изменились обе цены
            ticks[i].flags = TICK_FLAG_BID | TICK_FLAG_ASK;
           }

         //--- запись в базу через класс
         int added = stressSymb.TicksReplace(t1, t2, ticks);

         if(added != copied)
           {
            PrintFormat("Ошибка записи тиков за %s через класс. Записано: %d из %d",
                        TimeToString(day_start, TIME_DATE), added, copied);
           }
         else
           {
            total_ticks_added += added;
           }
        }

      //--- переходим к следующему дню
      current_date = day_end;
      Sleep(10);
     }

   Print("--- Генерация завершена ---");
   PrintFormat("Всего обработано тиков: %d", total_ticks_added);
  }
//+------------------------------------------------------------------+

Скрипт использует класс-обертку CiCustomSymbol для работы с пользовательскими символами. Полный код скрипта находится в файле «StressTest_SpreadModifier.mq5», приложенном к статье.


Сценарий 2: Уровни Stop Level и Freeze Level

Многие брокеры в периоды высокой волатильности (например, перед NFP-данными в США) увеличивают минимальное расстояние для установки стоп-лоссов (Stop Level) и уровень заморозки ордеров (Freeze Level). Если ваша стратегия ставит стоп-лосс на расстоянии 5 пунктов, а брокер в момент входа требует минимум 20 — ордер будет отклонен сервером, или позиция останется без стопа.

Как проверить это в MetaTrader 5? Свойства контракта задаются функцией CustomSymbolSetInteger(). Вы можете создать пользовательский символ, где SYMBOL_TRADE_STOPS_LEVEL завышен в 5–10 раз относительно нормы.

//--- установка экстремального стоп-левела (например, 500 пунктов)
long huge_stop_level = 500;
if(!CustomSymbolSetInteger(stress_symbol, SYMBOL_TRADE_STOPS_LEVEL, huge_stop_level))
   Print("Ошибка установки стоп-левела");
   
//--- установка уровня заморозки (чтобы нельзя было модифицировать ордера близко к рынку)
long huge_freeze_level = 500;
if(!CustomSymbolSetInteger(stress_symbol, SYMBOL_TRADE_FREEZE_LEVEL, huge_freeze_level))
   Print("Ошибка установки уровня заморозки");

После запуска тестера на таком символе обращайте внимание на журнал. Если стратегия пытается поставить стоп слишком близко, тестер выдаст ошибку «OrderSend error 130» (неверные стопы). Это позволит вам оценить, насколько стратегия зависит от возможности ставить близкие стопы.


Сценарий 3: Маржинальные требования и кредитное плечо

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

//--- увеличиваем требование к марже в 2 раза
double normal_margin = SymbolInfoDouble(source_symbol, SYMBOL_MARGIN_INITIAL);
double stress_margin = normal_margin * 2.0;

if(!CustomSymbolSetDouble(stress_symbol, SYMBOL_MARGIN_INITIAL, stress_margin))
   Print("Ошибка установки маржи");


Аналитическое отступление: Как отличить риск от артефакта

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

  • Плавная деградация — это хорошо. Если кривая эквити плавно снижается по мере ухудшения условий (рост спреда, увеличение стопов), значит, у стратегии есть запас прочности.
  • Резкий обрыв — это плохо. Если стратегия показывает плюс на спреде 20, но полный слив на спреде 21 — это грааль, подогнанный (переоптимизированный) под узкие условия. В реале такой робот долго не проживет.

Источники данных

Для корректного стресс-теста важна качество тиковой истории. Встроенные минутные бары (M1) не подходят для тестирования спреда, так как в них спред зашит в цену закрытия или вообще отсутствует как отдельная сущность. Используйте CopyTicks() и пользовательские символы, построенные на тиках.

Этапы тестирования стратегии:

  • Подготовка данных — скачайте качественные тики (например, с Dukascopy) или убедитесь, что в терминале загружена полная тиковая история,
  • Создание тестового полигона — используйте скрипт, который клонирует основной символ (например, EURUSD → EURUSD_Stress_50) и применяет модификаторы (спред, стопы, маржа),
  • Пакетный прогон — используйте оптимизатор тестера стратегий.

Лайфхак:

Вместо того чтобы менять код советника, меняйте символ, на котором он тестируется. Запустите оптимизацию по набору пользовательских символов: EURUSD_Normal, EURUSD_Spread_30, EURUSD_Spread_50. Сведите результаты (Net Profit, Drawdown) в таблицу или базу данных. Стратегия, которая остается в плюсе во всех сценариях, может быть рассмотрена для допуска на реальный счет.


Интеграция в рабочий процесс: от тестера к Live-графику

Предположим, мы создали пользовательские символы, сгенерировали на их основе вне-временные графики (Renko, Range) и протестировали стратегию в тестере. Но, здесь-то и кроется подводный камень: торговый сервер вашего брокера ничего не знает о существовании EURUSD_Renko_10.

Если вы попытаетесь отправить ордер на пользовательский символ напрямую, терминал вернет ошибку 4756 (Unknown Symbol). Пользовательские символы существуют только в клиентском терминале. Как же тогда заставить советник, который принимает решения на основе ренко-баров, торговать реальным EURUSD?

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

Проблема маршрутизации и виртуальная реальность

Когда эксперт размещен на графике пользовательского символа, системная переменная _Symbol возвращает имя этого пользовательского инструмента (например, XAGUSD_Range_10), что неудивительно. В то же время, советник, как правило, использует поле _Symbol или, что то же самое, системную функцию Symbol() для следующих операций:

  • Отправки ордеров;
  • Запроса котировок (SymbolInfoTick());
  • Проверки открытых позиций (PositionSelect и пр.).

Чтобы заставить его производить торговые операции с реальным рынком, нам нужно перехватить все эти вызовы и подставить вместо _Symbol имя реального инструмента (например, XAGUSD). Вручную переписывать код каждого советника — не наш метод. Решение простое — класс-обертка CustomOrder. Создадим класс, который дублирует ключевые функции торгового API MQL5. Внутри этих функций происходит проверка: если запрашивается текущий символ графика (пользовательский), мы подменяем его на реальный.

Чтобы не менять исходный код советников, мы воспользуемся директивой #define, которая на этапе препроцессора заменит стандартные вызовы на наши.

Реализация класса для работы с пользовательскими символами приведена ниже:

//+------------------------------------------------------------------+
//| класс для маршрутизации приказов                                 |
//| назначение: подмена пользовательского символа на реальный        |
//+------------------------------------------------------------------+
class CustomOrder
  {
private:
   static string     workSymbol; // имя реального символа

public:
   //--- установка символа-заменителя
   static void       setReplacementSymbol(const string replacement)
     {
      workSymbol = replacement;
     }

   //--- отправка торгового запроса
   static bool       OrderSend(MqlTradeRequest &request, MqlTradeResult &result)
     {
      //--- подмена символа в запросе
      if(request.symbol == _Symbol && workSymbol != "")
        {
         request.symbol = workSymbol;

         //--- корректировка цены, если она берется от кастом-символа
         if(request.type == ORDER_TYPE_BUY)
            request.price = SymbolInfoDouble(workSymbol, SYMBOL_ASK);
         else
            if(request.type == ORDER_TYPE_SELL)
               request.price = SymbolInfoDouble(workSymbol, SYMBOL_BID);
        }

      //--- вызов оригинальной функции
      return ::OrderSend(request, result);
     }

   //--- расчет прибыли
   static bool       OrderCalcProfit(ENUM_ORDER_TYPE action, string symbol, double volume,
                                     double price_open, double price_close, double &profit)
     {
      if(symbol == _Symbol && workSymbol != "")
         symbol = workSymbol;

      return ::OrderCalcProfit(action, symbol, volume, price_open, price_close, profit);
     }

   //--- получение строкового свойства позиции
   static string     PositionGetString(ENUM_POSITION_PROPERTY_STRING property_id)
     {
      string res = ::PositionGetString(property_id);
      //--- если запрашивается символ позиции, возвращаем имя графика, а не реальный
      if(property_id == POSITION_SYMBOL && res == workSymbol)
         return _Symbol;
      return res;
     }

   //--- получение строкового свойства ордера
   static string     OrderGetString(ENUM_ORDER_PROPERTY_STRING property_id)
     {
      string res = ::OrderGetString(property_id);
      if(property_id == ORDER_SYMBOL && res == workSymbol)
         return _Symbol;
      return res;
     }

   //--- выбор позиции по символу
   static bool       PositionSelect(string symbol)
     {
      if(symbol == _Symbol && workSymbol != "")
         return ::PositionSelect(workSymbol);
      return ::PositionSelect(symbol);
     }
  };

//+------------------------------------------------------------------+
//| статическая инициализация                                        |
//+------------------------------------------------------------------+
string CustomOrder::workSymbol = "";

//+------------------------------------------------------------------+
//| макросы для прозрачной интеграции                                |
//+------------------------------------------------------------------+
#define OrderSend(request, result) CustomOrder::OrderSend(request, result)
#define OrderCalcProfit(action, symbol, volume, open, close, profit) CustomOrder::OrderCalcProfit(action, symbol, volume, open, close, profit)
#define PositionGetString(prop) CustomOrder::PositionGetString(prop)
#define OrderGetString(prop) CustomOrder::OrderGetString(prop)
#define PositionSelect(symbol) CustomOrder::PositionSelect(symbol)
//+------------------------------------------------------------------+

Из особенностей реализации отметим, что макросы заменяют стандартные торговые функции терминала MetaTrader 5 с теми же параметрами. Полный код находится в файле «CustomOrder.mqh», приложенном к данной статье.


Пример интеграции в советник

Представим, что у нас есть стандартный советник TrendFollower, сгенерированный Мастером MQL5. Чтобы он мог торговать реальным активом, находясь на графике ренко, нам нужно сделать три шага:

1.Подключение заголовка — директива #include <CustomOrder.mqh> должна идти первой, до подключения стандартных библиотек. Это гарантирует, что макросы подменят вызовы еще до компиляции кода библиотеки.

//+------------------------------------------------------------------+
//|                                               TrendFollower.mq5  |
//+------------------------------------------------------------------+
#include <CustomOrder.mqh>
#include <Expert\Expert.mqh>
#include <Expert\Signal\MySignals\SignalMACD.mqh>
//--- остальные декларации...

2.Ввод входного параметра — добавляем параметр, чтобы указать советнику, на какой реальный символ отправлять приказы:

input string   InpWorkSymbol = "XAGUSD";   // Реальный символ для исполнения

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

int OnInit()
  {
//--- настраиваем маршрутизатор
   if(InpWorkSymbol != "")
     {
      CustomOrder::setReplacementSymbol(InpWorkSymbol);
      
      //--- принудительно подгружаем историю реального символа, чтобы визуализация шла плавно
      MqlRates rates[1];
      CopyRates(InpWorkSymbol, PERIOD_M1, 0, 1, rates);
     }

//--- стандартная инициализация эксперта...
// ...
   return(INIT_SUCCEEDED);
  }

После этих изменений эксперт будет анализировать графики XAGUSD_Renko_10, но все ордера будут отрабатываться на XAGUSD и в журнале сделок символ будет отображаться корректно.


Аналитическое отступление: устранение заглядывания в будущее в тестере

Зачем все это нужно, если можно просто тестировать на реальных данных? Вспомним раздел про Ренко. Мы выяснили, что тестер стратегий при тестировании на пользовательском символе генерирует тики на основе конфигурации бара (OHLC). Для Ренко-бара это создает иллюзию идеального входа: советник видит закрытие бара и сразу входит по цене закрытия. Однако в реальности кирпич формируется в течение некоторого времени. Цена может гулять внутри диапазона формирования бара.

Когда вы включаете маршрутизацию (используя класс CustomOrder) происходит следующее:

  1. Советник видит сигнал на графике с пользовательским символом (например, пересечение MA на Ренко),
  2. Он отправляет запрос на покупку (или продажу),
  3. Класс CustomOrder меняет символ на EURUSD,
  4. Сделка исполняется по текущей рыночной цене реального EURUSD.

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


Перед запуском реальной торговли на пользовательских символах убедитесь в следующем:

  • Синхронизация истории — убедитесь, что реальный символ имеет полную историю в терминале. Если данных нет, то CustomOrder может некорректно рассчитать маржу или цену входа;
  • Отсутствие ошибок с кодом 4756 — проверьте журнал экспертов. Если видите Unknown Symbol, значит, макросы не сработали (возможно, вы подключили CustomOrder.mqh после других библиотек);
  • Проскальзывание — при торговле через обертку вы получаете цену рынка. Убедитесь, что в настройках эксперта допустимое проскальзывание задано достаточно большим, чтобы ордера проходили при быстрых движениях, когда ренко-сигналы генерируются чаще, чем обновляется тик реального символа.

Если вы используете пользовательские символы для анализа, облачная оптимизация на MQL5 Cloud Network недоступна. Используйте локальную сеть и/или локальный компьютер.


Заключение

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

Мы научились отвязываться от календарной сетки через Renko, Range и Equal-Volume графики, синтезировать межрыночные связи через спреды и корзины, намеренно ломать историю для стресс-тестов и, наконец, связывать виртуальную торговлю с реальным исполнением через прозрачную маршрутизацию торговых приказов. Каждый из этих этапов закрывает конкретную проблему системного разработчика: шум таймфреймов, отсутствие нужных инструментов, иллюзия идеального бэктеста и разрыв между графиком и сервером.

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

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

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


Рекомендуемые материалы для изучения работы с пользовательскими символами в MetaTrader 5:


Список файлов, приложенных к статье:

Название файла Описание
CiCustomSymbol.mqh Файл, содержащий код класса CiCustomSymbol
CreateCustomSymbol.mq5 Файл, содержащий код скрипта-примера создания пользовательского символа
CBarAggregator.mqh Файл, содержащий код класса CBarAggregator
CustomChartGenerator.mq5 Файл, содержащий код индикатора, формирующего историю и live-бары трех типов: Ренко, Рейндж, равнообъемные
CSyntheticTickGenerator.mqh  Файл, содержащий код класса CSyntheticTickGenerator
StressTest_SpreadModifier.mq5 Файл, содержащий код скрипта-примера создания пользовательского символа для стресс-тестирования с большим спредом
CustomOrder.mqh Файл, содержащий код класса CustomOrder



    Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.

    MetaQuotes
    MetaQuotes
  • www.metaquotes.net
    • Компания MetaQuotes Ltd является разработчиком торговой платформы MetaTrader 5, которая позволяет торговать на разнообразных финансовых рынках.

    Скачать последние билды можно по указанным ниже ссылкам:
     • MetaTrader 5 для десктопа - https://download.terminal.free/cdn/web/metaquotes.ltd/mt5/mt5setup.exe
     • MetaTrader 5 iPhone - https://download.terminal.free/cdn/mobile/mt5/ios
     • MetaTrader 5 Android - https://download.terminal.free/cdn/mobile/mt5/android

    Другие статьи автора

    Перейти к обсуждению на форуме трейдеров
    Двумерные копулы в MQL5 (Часть 3): Реализация и настройка смешанных моделей копул Двумерные копулы в MQL5 (Часть 3): Реализация и настройка смешанных моделей копул
    В статье наш набор инструментов для работы с копулами расширяется смешанными копулами, реализованными непосредственно в MQL5. Мы строим смеси Клейтона–Франка–Гумбеля и Клейтона–Стьюдента-t–Гумбеля, оцениваем их с помощью EM и вводим управление разреженностью через SCAD с кросс-валидацией. Предоставленные скрипты настраивают гиперпараметры, сравнивают смеси с использованием информационных критериев и сохраняют обученные модели. Практики могут применять эти компоненты для учета асимметричной хвостовой зависимости и встраивать выбранную модель в индикаторы или советники.
    Алгоритм андского кондора — Andean Condor Algorithm (ACA) Алгоритм андского кондора — Andean Condor Algorithm (ACA)
    В статье реализован Andean Condor Algorithm (ACA) для MQL5 — компактный оптимизатор с многомасштабным оператором интенсификации. Выявлен эффект значимого роста качества при малой популяции: одна корректировка настроек выводит его в топ-45 — и за этим стоит характерная особенность алгоритма, о которой стоит знать. Материал даёт готовый код и практические ориентиры по применению.
    Оптимизация долгосрочных сделок: Свечи поглощения и стратегии работы с ликвидностью Оптимизация долгосрочных сделок: Свечи поглощения и стратегии работы с ликвидностью
    Это советник на основе высоких таймфреймов, который проводит долгосрочный анализ, принимает торговые решения и совершает сделки на базе анализа высоких таймфреймов W1, D1 и MN. В статье подробно рассматривается советник, специально разработанный для трейдеров, использующих долгосрочную торговлю и достаточно терпеливых, чтобы выдерживать волатильность младших таймфреймов и удерживать при этом свои позиции, не меняя слишком часто направление торговли, пока не достигнут целевых уровней фиксации прибыли.
    Тестер стратегий для Python и MetaTrader 5 (Часть 05): Тестер стратегий для нескольких символов и таймфреймов Тестер стратегий для Python и MetaTrader 5 (Часть 05): Тестер стратегий для нескольких символов и таймфреймов
    В этой статье представлен совместимый с MetaTrader 5 рабочий процесс бэктестинга, масштабируемый на разные символы и таймфреймы. Мы используем HistoryManager для параллельного сбора данных, синхронизации баров и тиков со всех таймфреймов и запуска изолированных по символам обработчиков OnTick в потоках. Вы узнаете, как режимы моделирования влияют на скорость и точность, когда стоит полагаться на данные терминала, как уменьшить операции ввода-вывода с помощью событийных обновлений и как собрать полноценного мультивалютного торгового робота.