English
preview
Создание системы прогнозного моделирования на основе пересечения EMA (Окончание): Интерактивные синтетические свечи

Создание системы прогнозного моделирования на основе пересечения EMA (Окончание): Интерактивные синтетические свечи

MetaTrader 5 — Примеры |
20 0
Hlomohang John Borotho
Hlomohang John Borotho

Содержание

  1. Введение
  2. Обзор системы
  3. Начало работы
  4. Демонстрация моделирования
  5. Заключение


Введение

В первой статье мы создали основные компоненты движка прогнозного моделирования для MetaTrader 5. Мы начали с простого детектора пересечения EMA. Затем мы добавили механизм задания точки привязки, цикл построения проекции на основе наклона EMA, правило аннулирования с порогом в пипсах и систему отрисовки с помощью графических объектов. В результате был создан автономный индикатор, способный строить проекцию из фиксированного числа синтетических свечей OHLC после подтвержденного пересечения EMA. Эти свечи отображались с видимыми телами и тенями, имели четкие подписи на графике и автоматически удалялись при аннулировании сигнала или появлении нового. Эта первоначальная версия заложила основу системы, включая обнаружение сигналов, управление состояниями, обработку объектов и повторяемый процесс формирования свечей. Она также показала, что визуализацию будущих движений цены можно интегрировать в традиционный индикатор EMA, сделав ее практически полезной.

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

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


Обзор системы

Индикатор построен на основе трех независимых модулей, каждый из которых выполняет одну конкретную функцию. Первый — сигнальный модуль, который отслеживает пересечение быстрой и медленной EMA по последним двум закрытым барам. Когда быстрая линия пересекает медленную снизу вверх, фиксируется бычье состояние; когда она пересекает ее сверху вниз — медвежье. Каждое новое пересечение сбрасывает движок и обновляет средние характеристики свечей на основе выборки последних закрытых баров текущего торгового инструмента на текущем таймфрейме. Эти показатели (средний размер тела свечи, средняя длина верхней тени и средняя длина нижней тени) становятся калибровочной основой для всего, что отрисовывается далее.

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

Как работает механизм калибровки:

  • Шаг 1: Сформировать выборку из последних 50 закрытых баров → Рассчитать средние размеры тел свечей и длины теней.
  • Шаг 2: Быстрая EMA пересекает медленную EMA снизу вверх → Сигнал зафиксирован, точка привязки установлена.
  • Шаг 3: Рассчитанные средние значения становятся основой для построения каждой будущей свечи.
  • Шаг 4: Панель в режиме реального времени отображает состояние сигнала и значения калибровки.

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

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

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

Как строится проекция будущих свечей:

  • Шаг 1: Размеры тел свечей изменяются по синусоидальному закону и постепенно уменьшаются к концу последовательности.
  • Шаг 2: Через каждые несколько баров контртрендовая свеча имитирует реалистичный откат.
  • Шаг 3: Длина каждой тени рассчитывается на основе откалиброванного отношения длины тени к размеру тела.
  • Шаг 4: По мере закрытия каждой реальной свечи исчезает самая старая свеча проекции — моделирование всегда опережает график на один бар.


Начало работы

//+------------------------------------------------------------------+
//|                                        Forward Simulation_V2.mq5 |
//|                                  Copyright 2025, MetaQuotes Ltd. |
//|                     https://www.mql5.com/en/users/johnhlomohang/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/en/users/johnhlomohang/"
#property version   "2.00"
#property indicator_chart_window
#property indicator_buffers   2

#property indicator_label1  "Fast EMA"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrDodgerBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  2

#property indicator_label2  "Slow EMA"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrOrangeRed
#property indicator_style2  STYLE_SOLID
#property indicator_width2  2

//+------------------------------------------------------------------+
//|  INDICATOR BUFFERS                                               |
//+------------------------------------------------------------------+
double FastEMABuffer[];
double SlowEMABuffer[];

//+------------------------------------------------------------------+
//|  INPUT PARAMETERS                                                |
//+------------------------------------------------------------------+
input int    FastEMA_Period     = 9;            // Fast EMA period
input int    SlowEMA_Period     = 21;           // Slow EMA period
input int    FutureBars         = 30;           // Number of future candles to project
input double SpreadMultiplier   = 2.0;          // Wick size multiplier
input bool   AutoAnchor         = true;         // Auto-move anchor to latest cross bar
input string AnchorLineName     = "FSE_Anchor"; // Anchor vertical line name
input color  BullishColor       = clrDodgerBlue;    // Bullish body color
input color  BearishColor       = clrCrimson;       // Bearish body color
input color  WickColor          = clrDimGray;       // Wick color
input bool   ShowZoneLabel      = true;         // Show projection label
input bool   ShowSeparatorLine  = true;         // Show dashed separator at anchor
input int    InvalidationPips   = 10;           // Pip distance to trigger invalidation
input double CandleGapFraction  = 0.08;         // Gap between candles as fraction of bar width (0.04–0.20)
input int    CounterCandleFreq  = 4;            // Insert 1 counter-trend candle every N candles (min 3)
input int    AvgLookback        = 50;           // Bars used to measure average candle size

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

//+------------------------------------------------------------------+
//|  STRUCTS                                                         |
//+------------------------------------------------------------------+
struct PredictedCandle
  {
   double            open;
   double            high;
   double            low;
   double            close;
   bool              bullish;
  };

//+------------------------------------------------------------------+
//|  GLOBALS                                                         |
//+------------------------------------------------------------------+
int      g_FastHandle    = INVALID_HANDLE;
int      g_SlowHandle    = INVALID_HANDLE;

int      g_LastSignal    = 0;     // +1 bull, -1 bear, 0 none
bool     g_SignalActive  = false;
double   g_SignalPrice   = 0.0;
datetime g_SignalBarTime = 0;
datetime g_DrawnAnchor   = 0;     // anchor time of the last successful draw

//--- Measured average candle metrics (refreshed on each new signal) 
double   g_AvgBody       = 0.0;  // average |close - open|  over AvgLookback bars
double   g_AvgUpperWick  = 0.0;  // average (high - max(open,close))
double   g_AvgLowerWick  = 0.0;  // average (min(open,close) - low)
double   g_AvgRange      = 0.0;  // average (high - low)  – full candle height

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   //--- Bind and configure the two visible EMA plot buffers
   SetIndexBuffer(0, FastEMABuffer, INDICATOR_DATA);
   SetIndexBuffer(1, SlowEMABuffer, INDICATOR_DATA);

   ArraySetAsSeries(FastEMABuffer, false);
   ArraySetAsSeries(SlowEMABuffer, false);

   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, FastEMA_Period);
   PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, SlowEMA_Period);

   //--- Internal calculation handles
   g_FastHandle = iMA(_Symbol, _Period, FastEMA_Period, 0, MODE_EMA, PRICE_CLOSE);
   g_SlowHandle = iMA(_Symbol, _Period, SlowEMA_Period, 0, MODE_EMA, PRICE_CLOSE);

   if(g_FastHandle == INVALID_HANDLE || g_SlowHandle == INVALID_HANDLE)
     {
      Print("ForwardSimEngine [ERROR]: iMA handle creation failed. "
            "Symbol=", _Symbol, " TF=", EnumToString(_Period));
      return INIT_FAILED;
     }

   Print("ForwardSimEngine [INIT]: OK  FastEMA=", FastEMA_Period,
         "  SlowEMA=", SlowEMA_Period,
         "  FutureBars=", FutureBars,
         "  InvalidationPips=", InvalidationPips,
         "  AvgLookback=", AvgLookback);

   //--- Pre-compute average candle metrics from history
   CalcAvgCandleMetrics();

   EventSetTimer(3);
   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   EventKillTimer();
   CleanAllObjects();
   Print("ForwardSimEngine [DEINIT]: objects cleaned, reason=", reason);
  }

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

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

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

//+-----------------------------------------------------------------------+
//| ON CALCULATE                                                          |
//+-----------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double   &open[],
                const double   &high[],
                const double   &low[],
                const double   &close[],
                const long     &tick_volume[],
                const long     &volume[],
                const int      &spread[])
  {
   if(rates_total < SlowEMA_Period + 5)
     {
      Print("ForwardSimEngine [WARN]: Not enough bars: ", rates_total);
      return 0;
     }

   //--- How many bars to (re)calculate
   int limit = (prev_calculated > 1) ? rates_total - prev_calculated + 1
               : rates_total;
   //--- Start index in the buffer (oldest bar that needs updating)
   int startBar = rates_total - limit;

   //--- Local arrays for engine logic
   double tmpFast[], tmpSlow[];
   ArraySetAsSeries(tmpFast, false);
   ArraySetAsSeries(tmpSlow, false);
   ArrayResize(tmpFast, rates_total);
   ArrayResize(tmpSlow, rates_total);

   //--- Copy ALL bars into local arrays (needed by RunEngine for crossover)
   int copiedFast = CopyBuffer(g_FastHandle, 0, 0, rates_total, tmpFast);
   int copiedSlow = CopyBuffer(g_SlowHandle, 0, 0, rates_total, tmpSlow);

   if(copiedFast <= 0 || copiedSlow <= 0)
     {
      Print("ForwardSimEngine [WARN]: CopyBuffer returned <=0. fast=",
            copiedFast, " slow=", copiedSlow);
      return prev_calculated;
     }

   /* Write into plot buffers ONLY within the confirmed copied range
      and only within what MT5 has allocated (ArraySize guard).*/
   int bufSzFast = ArraySize(FastEMABuffer);
   int bufSzSlow = ArraySize(SlowEMABuffer);
   int safeFast  = MathMin(copiedFast, bufSzFast);
   int safeSlow  = MathMin(copiedSlow, bufSzSlow);

   for(int i = startBar; i < safeFast; i++)
      FastEMABuffer[i] = tmpFast[i];
   for(int i = startBar; i < safeSlow; i++)
      SlowEMABuffer[i] = tmpSlow[i];

// ── Run the simulation engine ─────────────────────────────────
   RunEngine(rates_total, time, close, tmpFast, tmpSlow);

   return rates_total;
  }

//+------------------------------------------------------------------+
//| ON TIMER                                                         |
//+------------------------------------------------------------------+
void OnTimer()
  {
   // If user moved the anchor manually, force a redraw on next tick
   if(!AutoAnchor)
     {
      datetime curAnchor = GetAnchorTime();
      if(curAnchor != g_DrawnAnchor && curAnchor != 0)
        {
         g_DrawnAnchor = 0;
         ChartRedraw();
        }
     }
  }

Функция OnCalculate() представляет собой основной цикл выполнения. Она запускается при появлении новых рыночных данных. Для начала мы проверяем, достаточно ли исторических баров для расчета медленной EMA. Если данных недостаточно, функция записывает предупреждение в журнал и досрочно завершает работу. Затем мы вычисляем, сколько баров требуют пересчета, исходя из значения prev_calculated. Это позволяет избежать обработки всей истории данных при каждом тике. Затем создаются временные массивы для хранения значений быстрой и медленной EMA, которые копируются из внутренних дескрипторов EMA с помощью функции CopyBuffer(). Убедившись, что данные успешно скопированы, мы переносим значения в индикаторные буферы, используемые для отображения, и выполняем проверки, предотвращающие запись за пределы выделенного размера буфера.

После обновления данных EMA мы передаем актуальную рыночную информацию и массивы EMA в функцию RunEngine(), где выполняются алгоритмы обнаружения пересечений EMA, генерации проекций и отрисовки. Затем функция OnCalculate() возвращает общее количество обработанных баров, что позволяет MetaTrader 5 правильно отслеживать последующие обновления. Функция OnTimer() обеспечивает дополнительную поддержку ручного управления точкой привязки. Когда автоматическая привязка отключена, система постоянно отслеживает положение заданной пользователем точки привязки. Если точка привязки перемещается в новое место, функция принудительно запускает перерисовку, сбрасывая сохраненное состояние последней отрисованной точки привязки и запрашивая обновление графика. Это обеспечивает соответствие положения свечей проекции выбранной пользователем точке привязки без необходимости перезагрузки индикатора.

//+------------------------------------------------------------------+
//| CALC AVERAGE CANDLE METRICS                                      |
//+------------------------------------------------------------------+
void CalcAvgCandleMetrics()
  {
   int lookback = (AvgLookback < 10) ? 10 : AvgLookback;  // minimum 10 bars

   double hiBuf[], loBuf[], opBuf[], clBuf[];
   ArraySetAsSeries(hiBuf, true);
   ArraySetAsSeries(loBuf, true);
   ArraySetAsSeries(opBuf, true);
   ArraySetAsSeries(clBuf, true);

   //--- Copy starting at shift 1 (skip the live bar), going back lookback bars
   int copiedH = CopyHigh(_Symbol, _Period, 1, lookback, hiBuf);
   int copiedL = CopyLow(_Symbol, _Period, 1, lookback, loBuf);
   int copiedO = CopyOpen(_Symbol, _Period, 1, lookback, opBuf);
   int copiedC = CopyClose(_Symbol, _Period, 1, lookback, clBuf);

   int n = MathMin(MathMin(copiedH, copiedL), MathMin(copiedO, copiedC));
   if(n <= 0)
     {
      Print("ForwardSimEngine [AVG]: CopyPrice failed, keeping previous averages.");
      return;
     }

   double sumBody = 0, sumUWick = 0, sumLWick = 0, sumRange = 0;
   for(int i = 0; i < n; i++)
     {
      double bodyTop  = MathMax(opBuf[i], clBuf[i]);
      double bodyBot  = MathMin(opBuf[i], clBuf[i]);
      sumBody  += bodyTop - bodyBot;
      sumUWick += hiBuf[i] - bodyTop;
      sumLWick += bodyBot  - loBuf[i];
      sumRange += hiBuf[i] - loBuf[i];
     }

   double pip = _Point * 10.0;  // 1 pip floor

   g_AvgBody      = MathMax(sumBody  / n, pip);
   g_AvgUpperWick = MathMax(sumUWick / n, pip * 0.5);
   g_AvgLowerWick = MathMax(sumLWick / n, pip * 0.5);
   g_AvgRange     = MathMax(sumRange / n, pip * 2.0);

   Print("ForwardSimEngine [AVG]: lookback=", n,
         "  AvgBody=",      DoubleToString(g_AvgBody      / _Point, 1), " pts",
         "  AvgUpperWick=", DoubleToString(g_AvgUpperWick / _Point, 1), " pts",
         "  AvgLowerWick=", DoubleToString(g_AvgLowerWick / _Point, 1), " pts",
         "  AvgRange=",     DoubleToString(g_AvgRange     / _Point, 1), " pts");
  }

//+------------------------------------------------------------------+
//| CORE ENGINE                                                      |
//| All arrays: index 0 = oldest,  rates_total-1 = live forming bar  |
//|            rates_total-2 = last fully closed bar  (bar index 1)  |
//|            rates_total-3 = bar before that         (bar index 2) |
//+------------------------------------------------------------------+
void RunEngine(const int      rates_total,
               const datetime &time[],
               const double   &close[],
               const double   &fastBuf[],
               const double   &slowBuf[])
  {
   int barLive    = rates_total - 1; // live/forming bar
   int barClosed  = rates_total - 2; // last fully closed bar
   int barPrev    = rates_total - 3; // bar before that

   if(barPrev < SlowEMA_Period)
      return;

   //--- 1. Crossover detection 
   //--- We look at the two most recently CLOSED bars (barPrev and barClosed).
   //--- Cross occurs when the fast EMA crossed over the slow EMA between them.
   double fCur  = fastBuf[barClosed];
   double fPrev = fastBuf[barPrev];
   double sCur  = slowBuf[barClosed];
   double sPrev = slowBuf[barPrev];

   int newSignal = 0;
   if(fPrev <= sPrev && fCur > sCur)
      newSignal =  1; // bullish
   if(fPrev >= sPrev && fCur < sCur)
      newSignal = -1; // bearish

   //--- Heartbeat log (first 3 ticks + every new signal)
   static int s_ticks = 0;
   s_ticks++;
   if(s_ticks <= 3 || newSignal != 0)
     {
      Print("ForwardSimEngine [TICK #", s_ticks, "]",
            "  fCur=",   DoubleToString(fCur,  _Digits),
            "  sCur=",   DoubleToString(sCur,  _Digits),
            "  gap=",    DoubleToString(fCur - sCur, _Digits),
            "  newSig=", newSignal,
            "  active=", g_SignalActive,
            "  lastSig=",g_LastSignal);
     }

   //--- 2. Latch new signal
   if(newSignal != 0)
     {
      g_LastSignal    = newSignal;
      g_SignalActive  = true;
      g_SignalPrice   = close[barClosed];
      g_SignalBarTime = time[barClosed];
      g_DrawnAnchor   = 0; // force full redraw

      /* Refresh measured candle averages at the moment of the signal
         so the projection uses the most recent volatility context. */
      CalcAvgCandleMetrics();

      Print("ForwardSimEngine [SIGNAL]: ",
            (newSignal == 1 ? ">>> BULLISH CROSS <<<" : ">>> BEARISH CROSS <<<"),
            "  bar=", TimeToString(g_SignalBarTime),
            "  px=",  DoubleToString(g_SignalPrice, _Digits));
     }

   //--- 3. Invalidation check 
   if(g_SignalActive)
     {
      double livePx = close[barLive];
      //--- 1 pip = 10 * _Point for a 5-digit broker (covers 3-digit too)
      double pipSize = _Point * 10.0;
      double thresh  = InvalidationPips * pipSize;

      bool inv = false;
      if(g_LastSignal ==  1 && livePx < g_SignalPrice - thresh)
         inv = true;
      if(g_LastSignal == -1 && livePx > g_SignalPrice + thresh)
         inv = true;

      if(inv)
        {
         Print("ForwardSimEngine [INVALIDATED]",
               "  signalPx=", DoubleToString(g_SignalPrice, _Digits),
               "  livePx=",   DoubleToString(livePx, _Digits),
               "  thresh=",   DoubleToString(thresh,  _Digits));

         g_SignalActive = false;
         g_LastSignal   = 0;
         g_DrawnAnchor  = 0;
         CleanAllObjects();
         DrawInvalidationLabel(g_SignalBarTime, g_SignalPrice);
         ChartRedraw();
         return;
        }
     }

   //--- 4. Only draw/redraw when there is an active signal
   if(!g_SignalActive || g_LastSignal == 0)
      return;

   datetime anchorTime = (AutoAnchor) ? g_SignalBarTime : GetAnchorTime();
   if(anchorTime == 0)
      anchorTime = g_SignalBarTime;

   //--- Skip if already drawn at this anchor
   if(anchorTime == g_DrawnAnchor)
      return;
   g_DrawnAnchor = anchorTime;

   //--- 5. Build synthetic candles 
   double emaSlope = fCur - fPrev;
   PredictedCandle pred[];
   ArrayResize(pred, FutureBars);
   GeneratePrediction(close[barClosed], emaSlope, pred);

   //--- 6. Render 
   CleanAllObjects();
   DrawAllCandles(anchorTime, pred);
   if(ShowSeparatorLine)
      DrawSeparator(anchorTime);
   if(ShowZoneLabel)
      DrawZoneLabel(anchorTime, close[barClosed]);
   UpdateAnchorLine(anchorTime);
   ChartRedraw();

   Print("ForwardSimEngine [DRAWN]",
         "  signal=",   g_LastSignal,
         "  anchor=",   TimeToString(anchorTime),
         "  bars=",     FutureBars,
         "  slope=",    DoubleToString(emaSlope, _Digits));
  }

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

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

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

//+------------------------------------------------------------------+
//|  PREDICTION ENGINE                                               |
//+------------------------------------------------------------------+
void GeneratePrediction(double startPrice, double emaSlope, PredictedCandle &out[])
  {
   MathSrand((int)(TimeLocal() % 32767));

   int    n   = ArraySize(out);
   int    sig = g_LastSignal;   // +1 bull, -1 bear
   double pip = _Point * 10.0;

   //--- Baseline body size from measured history 
   //--- Guard: if CalcAvgCandleMetrics hasn't run yet use a pip floor
   double avgBody  = (g_AvgBody  > pip) ? g_AvgBody  : pip * 3.0;
   double avgUWick = (g_AvgUpperWick > 0) ? g_AvgUpperWick : avgBody * 0.5;
   double avgLWick = (g_AvgLowerWick > 0) ? g_AvgLowerWick : avgBody * 0.5;

   //--- EMA-slope momentum scale: 0.5× (weak) … 1.5× (strong)
   //--- Normalise slope against avgBody so it is always unit-consistent
   double slopeAbs   = MathAbs(emaSlope);
   double slopeRatio = slopeAbs / avgBody;          // 0 = flat, 1 = slope equals avg body
   //--- Clamp to a ±0.5 band around 1.0
   double momentumScale = 0.5 + MathMin(slopeRatio, 1.0);  // 0.5 … 1.5

   //--- baseStep = what one average trend-direction candle body should be
   double baseStep = avgBody * momentumScale;

   //--- Counter-candle frequency guard
   int ccFreq = (CounterCandleFreq < 3) ? 3 : CounterCandleFreq;

   double prevClose = startPrice;

   for(int i = 0; i < n; i++)
     {
      //--- Sine envelope: body pulses between 40% and 130% of baseStep 
      double phase    = (double)i / (double)n * 2.0 * M_PI;
      double sinSq    = MathSin(phase) * MathSin(phase);   // 0 … 1
      double envelope = 0.40 + 0.90 * sinSq;               // 0.40 … 1.30

      //--- Exponential decay: projection flattens toward the tail
      double decay    = MathPow(0.93, i);

      //--- Body for this candle
      double bodySize = baseStep * envelope * decay;

      //--- ±8% random jitter
      double jitter   = 1.0 + ((double)(MathRand() % 160) - 80.0) * 0.001;
      bodySize       *= jitter;

      //--- Hard floor: at least 0.5 × avgBody so candles are always visible
      if(bodySize < avgBody * 0.5)
         bodySize = avgBody * 0.5;

      //--- Counter-trend injection every ccFreq bars 
      bool   isCounter   = (i > 0 && (i % ccFreq == 0));
      double retracePct  = 0.25 + (MathRand() % 21) * 0.01;  // 0.25–0.45
      double step;
      if(isCounter)
         step = -(double)sig * bodySize * retracePct;
      else
         step = (double)sig * bodySize;

      //--- OHLC 
      out[i].open    = prevClose;
      out[i].close   = prevClose + step;
      out[i].bullish = (out[i].close >= out[i].open);

      double bodyTop = MathMax(out[i].open, out[i].close);
      double bodyBot = MathMin(out[i].open, out[i].close);
      double bHeight = bodyTop - bodyBot;
      if(bHeight < _Point)
         bHeight = _Point;

      //--- Wicks anchored to measured avg wick ratios 
      //--- Base ratio = avgWick / avgBody, then add ±25% random spread
      double uRatioBase = avgUWick / avgBody;
      double lRatioBase = avgLWick / avgBody;

      double uJitter = 1.0 + ((double)(MathRand() % 50) - 25.0) * 0.01; // ±25%
      double lJitter = 1.0 + ((double)(MathRand() % 50) - 25.0) * 0.01;

      double upWick = bHeight * uRatioBase * uJitter;
      double dnWick = bHeight * lRatioBase * lJitter;

      //--- Trend bias: the shadow in the signal direction is slightly longer
      if(out[i].bullish)
         upWick *= 1.20;
      else
         dnWick *= 1.20;

      //--- Minimum wick: 20% of body height
      if(upWick < bHeight * 0.20)
         upWick = bHeight * 0.20;
      if(dnWick < bHeight * 0.20)
         dnWick = bHeight * 0.20;

      out[i].high = bodyTop + upWick;
      out[i].low  = bodyBot - dnWick;

      prevClose = out[i].close;
     }
  }

//+------------------------------------------------------------------+
//| DRAW ALL CANDLES – project one bar-width ahead of anchor         |
//+------------------------------------------------------------------+
void DrawAllCandles(datetime startTime, PredictedCandle &candles[])
  {
   int barSec  = PeriodSeconds();
   int total   = ArraySize(candles);

   //--- Gap in seconds on each side of the body (max 45% each side)
   double gapFrac = CandleGapFraction;
   if(gapFrac < 0.01)
      gapFrac = 0.01;
   if(gapFrac > 0.45)
      gapFrac = 0.45;
   int gapSec = (int)(barSec * gapFrac);

   for(int i = 0; i < total; i++)
     {
      //--- Slot boundaries (full bar width)
      datetime slotStart = startTime + (datetime)((i + 1) * barSec);
      datetime slotEnd   = slotStart  + (datetime)barSec;

      //--- Body boundaries (inset by gap on each side)
      datetime bodyStart = slotStart + (datetime)gapSec;
      datetime bodyEnd   = slotEnd   - (datetime)gapSec;
      datetime bodyMid   = slotStart + (datetime)(barSec / 2); // wick centre

      DrawSingleCandle(i, bodyStart, bodyEnd, bodyMid, candles[i]);
     }
  }

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

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

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

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

//+------------------------------------------------------------------+
//|  DRAW ONE CANDLE                                                 |
//+------------------------------------------------------------------+
void DrawSingleCandle(int idx,
                      datetime t1, datetime t2, datetime tMid,
                      const PredictedCandle &c)
  {
   string pfx    = "FutureCandle_" + IntegerToString(idx);
   color  bodyCol = c.bullish ? BullishColor : BearishColor;

   //--- Doji guard
   double bOpen  = c.open;
   double bClose = c.close;
   if(MathAbs(bOpen - bClose) < _Point)
      bClose = bOpen + (c.bullish ? _Point * 2 : -_Point * 2);

   //--- Filled body 
   string nm = pfx + "_body";
   ObjectDelete(0, nm);
   if(ObjectCreate(0, nm, OBJ_RECTANGLE, 0, t1, bOpen, t2, bClose))
     {
      ObjectSetInteger(0, nm, OBJPROP_COLOR,      bodyCol);
      ObjectSetInteger(0, nm, OBJPROP_FILL,       true);
      ObjectSetInteger(0, nm, OBJPROP_BACK,       false);
      ObjectSetInteger(0, nm, OBJPROP_WIDTH,      1);
      ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, nm, OBJPROP_HIDDEN,     false);
     }

   //--- Body outline
   nm = pfx + "_bord";
   ObjectDelete(0, nm);
   if(ObjectCreate(0, nm, OBJ_RECTANGLE, 0, t1, bOpen, t2, bClose))
     {
      ObjectSetInteger(0, nm, OBJPROP_COLOR,      bodyCol);
      ObjectSetInteger(0, nm, OBJPROP_FILL,       false);
      ObjectSetInteger(0, nm, OBJPROP_BACK,       false);
      ObjectSetInteger(0, nm, OBJPROP_WIDTH,      1);
      ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, nm, OBJPROP_HIDDEN,     false);
     }

   //--- Upper wick  (centred on full slot, not the inset body) 
   nm = pfx + "_wU";
   ObjectDelete(0, nm);
   double wTop = MathMax(bOpen, bClose);
   if(ObjectCreate(0, nm, OBJ_TREND, 0, tMid, wTop, tMid, c.high))
     {
      ObjectSetInteger(0, nm, OBJPROP_COLOR,      WickColor);
      ObjectSetInteger(0, nm, OBJPROP_WIDTH,      1);
      ObjectSetInteger(0, nm, OBJPROP_RAY_RIGHT,  false);
      ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, nm, OBJPROP_HIDDEN,     false);
     }

   //--- Lower wick 
   nm = pfx + "_wD";
   ObjectDelete(0, nm);
   double wBot = MathMin(bOpen, bClose);
   if(ObjectCreate(0, nm, OBJ_TREND, 0, tMid, wBot, tMid, c.low))
     {
      ObjectSetInteger(0, nm, OBJPROP_COLOR,      WickColor);
      ObjectSetInteger(0, nm, OBJPROP_WIDTH,      1);
      ObjectSetInteger(0, nm, OBJPROP_RAY_RIGHT,  false);
      ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, nm, OBJPROP_HIDDEN,     false);
     }
  }

//+------------------------------------------------------------------+
//| SEPARATOR                                                        |
//+------------------------------------------------------------------+
void DrawSeparator(datetime t)
  {
   string nm = "FSE_Sep";
   ObjectDelete(0, nm);
   if(ObjectCreate(0, nm, OBJ_VLINE, 0, t, 0))
     {
      ObjectSetInteger(0, nm, OBJPROP_COLOR,      clrSilver);
      ObjectSetInteger(0, nm, OBJPROP_STYLE,      STYLE_DASH);
      ObjectSetInteger(0, nm, OBJPROP_WIDTH,      1);
      ObjectSetInteger(0, nm, OBJPROP_BACK,       true);
      ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, nm, OBJPROP_HIDDEN,     false);
     }
  }

//+------------------------------------------------------------------+
//| ZONE LABEL                                                       |
//+------------------------------------------------------------------+
void DrawZoneLabel(datetime t, double price)
  {
   string nm  = "FSE_Label";
   string txt = (g_LastSignal == 1) ? "[ BULLISH PROJECTION ]" : "[ BEARISH PROJECTION ]";
   color  col = (g_LastSignal == 1) ? BullishColor : BearishColor;

   ObjectDelete(0, nm);
   if(ObjectCreate(0, nm, OBJ_TEXT, 0, t + (datetime)PeriodSeconds(), price))
     {
      ObjectSetString(0,  nm, OBJPROP_TEXT,       txt);
      ObjectSetInteger(0, nm, OBJPROP_COLOR,      col);
      ObjectSetInteger(0, nm, OBJPROP_FONTSIZE,   10);
      ObjectSetString(0,  nm, OBJPROP_FONT,       "Courier New");
      ObjectSetInteger(0, nm, OBJPROP_ANCHOR,     ANCHOR_LEFT_LOWER);
      ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, nm, OBJPROP_HIDDEN,     false);
     }
  }

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

Остальные функции добавляют вспомогательные графические элементы, которые повышают наглядность зоны проекции. Функция DrawSingleCandle() завершает отрисовку свечи, проводя линии верхней и нижней теней по центру выделенного для свечи временного интервала. Функция DrawSeparator() размещает вертикальную штриховую линию в точке привязки, создавая четкую визуальную границу между историческими рыночными данными и свечами проекции. Затем функция DrawZoneLabel() добавляет поясняющую текстовую метку, указывающую, является ли проекция бычьей или медвежьей. Метка располагается вблизи начала области проекции и окрашивается в цвет, соответствующий активному сигналу.

//+------------------------------------------------------------------+
//|  INVALIDATION LABEL                                              |
//+------------------------------------------------------------------+
void DrawInvalidationLabel(datetime t, double price)
  {
   string nm = "FSE_Invalid";
   ObjectDelete(0, nm);
   if(ObjectCreate(0, nm, OBJ_TEXT, 0, t + (datetime)PeriodSeconds(), price))
     {
      ObjectSetString(0,  nm, OBJPROP_TEXT,       "[ INVALIDATED - AWAITING NEXT CROSS ]");
      ObjectSetInteger(0, nm, OBJPROP_COLOR,      clrOrange);
      ObjectSetInteger(0, nm, OBJPROP_FONTSIZE,   9);
      ObjectSetString(0,  nm, OBJPROP_FONT,       "Courier New");
      ObjectSetInteger(0, nm, OBJPROP_ANCHOR,     ANCHOR_LEFT_LOWER);
      ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, nm, OBJPROP_HIDDEN,     false);
     }
  }

//+------------------------------------------------------------------+
//|  ANCHOR LINE HELPERS                                             |
//+------------------------------------------------------------------+
void PlaceAnchorLine(datetime t)
  {
   ObjectDelete(0, AnchorLineName);
   if(ObjectCreate(0, AnchorLineName, OBJ_VLINE, 0, t, 0))
     {
      ObjectSetInteger(0, AnchorLineName, OBJPROP_COLOR,      clrGold);
      ObjectSetInteger(0, AnchorLineName, OBJPROP_STYLE,      STYLE_DASHDOTDOT);
      ObjectSetInteger(0, AnchorLineName, OBJPROP_WIDTH,      2);
      ObjectSetInteger(0, AnchorLineName, OBJPROP_SELECTABLE, true);
      ObjectSetInteger(0, AnchorLineName, OBJPROP_HIDDEN,     false);
     }
  }

//+------------------------------------------------------------------+
//|  Update Anchor Line                                              |
//+------------------------------------------------------------------+
void UpdateAnchorLine(datetime t)
  {
   if(ObjectFind(0, AnchorLineName) < 0)
      PlaceAnchorLine(t);
   else
      ObjectSetInteger(0, AnchorLineName, OBJPROP_TIME, t);
  }

//+------------------------------------------------------------------+
//|  Get Anchor Time                                                 |
//+------------------------------------------------------------------+
datetime GetAnchorTime()
  {
   if(ObjectFind(0, AnchorLineName) >= 0)
      return (datetime)ObjectGetInteger(0, AnchorLineName, OBJPROP_TIME);
   return 0;
  }

//+------------------------------------------------------------------+
//|  CLEANUP                                                         |
//+------------------------------------------------------------------+
void CleanAllObjects()
  {
   ObjectsDeleteAll(0, "FutureCandle_");
   ObjectsDeleteAll(0, "FSE_");
  }
//+------------------------------------------------------------------+

Функция DrawnIvalidationLabel() визуально оповещает об аннулировании активной проекции. Когда выполняются условия аннулирования, мы сначала удаляем существующую метку аннулирования, чтобы избежать дублирования. Затем рядом с местом появления аннулированного сигнала создается текстовый объект с сообщением о том, что проекция отменена и движок ожидает следующего пересечения EMA. Для метки задаются оранжевый цвет, определенный шрифт и способ привязки текста. Это сразу подтверждает трейдерам, что предыдущий прогноз больше не считается действительным.

Функции управления точкой привязки позволяют нам задавать, где на графике начинается проекция. Функция PlaceAnchorLine() создает перемещаемую вертикальную линию, которая задает точку привязки проекции, а функция UpdateAnchorLine() создает линию привязки, если она отсутствует, или при необходимости перемещает ее в новое положение. Функция GetAnchorTime() получает текущую временную метку точки привязки, позволяя другим компонентам движка правильно размещать свечи проекции по времени. Наконец, функция CleanAllObjects() выполняет очистку, удаляя все графические объекты, созданные движком прогнозного моделирования. Это гарантирует удаление устаревших свечей, меток и маркеров перед построением новой проекции, поддерживая чистоту графика и предотвращая накопление объектов с течением времени.

Демонстрация моделирования


Заключение

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

Самым важным нововведением является калибровочный слой. Вместо того чтобы полагаться исключительно на наклон EMA, движок теперь рассчитывает средний размер тела и средние длины верхней и нижней теней последних закрытых свечей с помощью функций CopyOpen, CopyHigh, CopyLow и CopyClose. Благодаря этому каждая проекция отражает фактическую волатильность текущего торгового инструмента на выбранном таймфрейме. Проекция для "XAUUSD M15" теперь напоминает реальное движение цены на графике XAUUSD с таймфреймом M15, а не обобщенную приблизительную оценку. Наклон EMA по-прежнему используется как фактор импульса: более сильные сигналы позволяют формировать более крупные синтетические свечи, сохраняя при этом соответствие реальным рыночным условиям.

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

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

Архитектура по-прежнему остается модульной и легко расширяемой. Такие компоненты, как CalcAvgCandleMetrics, GeneratePrediction, DrawAllCandles и конечный автомат управления состояниями сигнала, работают независимо друг от друга. Разработчики могут заменить механизм запуска по пересечению EMA моделью на основе рыночной структуры, внедрить систему учета волатильности на основе ATR или добавить визуальные эффекты, зависящие от степени уверенности в прогнозе, не изменяя слои отрисовки и аннулирования. Таким образом, программная основа, разработанная в этих двух статьях, представляет собой нечто большее, чем просто готовый индикатор. Она служит понятной и расширяемой основой для создания продвинутых инструментов построения проекций и визуализации сценариев в MetaTrader 5.

Сопровождение этой статьи осуществляется на платформе AlgoForge.

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

Прикрепленные файлы |
For_sim.mq5 (27.49 KB)
Разработка индикатора внутренней и внешней структуры рынка Разработка индикатора внутренней и внешней структуры рынка
В статье представлен структурированный подход к анализу внешней и внутренней структуры рынка в MQL5 — от выявления свингов до проверки сигналов CHoCH/BoS в рамках сформировавшегося тренда. В ней объясняется, как уточнять истинные максимумы и минимумы, применять логику "первого внутреннего сигнала", а также отображать линии, метки и маркеры на графике. В результате получается индикатор с согласованной логикой работы, который преобразует ценовую структуру в чётко определённые уровни входа, стоп-лосса и целевые уровни 1,5R.
Торговые инструменты MQL5 (Часть 36): Фигуры и аннотации в слое рисования с редактированием меток прямо на холсте Торговые инструменты MQL5 (Часть 36): Фигуры и аннотации в слое рисования с редактированием меток прямо на холсте
Мы добавляем на холст восемь инструментов для рисования фигур и девять инструментов для создания аннотаций, а также реализуем полнофункциональную систему редактирования меток на месте. В статье подробно рассматриваются геометрия, отрисовка со сглаживанием, общие вспомогательные функции для переноса слов и отрисовки текста с суперсэмплингом, а также конечный автомат редактирования, основанный на положении текстового курсора и отвечающий за ввод текста, навигацию и выделение. В результате получается полный и согласованный набор инструментов для аннотирования с редактируемыми метками, который интегрируется в существующий конвейер взаимодействия.
Особенности написания экспертов Особенности написания экспертов
Написание и тестирование экспертов в торговой системе MetaTrader 4.
Автоматизация классических рыночных методов на MQL5 (Часть 6): Система ключевых точек Джесси Ливермора Автоматизация классических рыночных методов на MQL5 (Часть 6): Система ключевых точек Джесси Ливермора
В данной статье представлен готовый советник на языке MQL5, в котором «рыночный ключ» Джесси Ливермора реализован в виде детерминированного конечного автомата. Он определяет ключевые уровни по консолидациям, используя ATR и рост объема, поэтапно наращивает позиции четырьмя траншами и закрывает их при аномальном поведении, определяемом по диапазону и объему. Советник проверяет входные параметры в OnInit, требует хеджингового счета и компилируется без дополнительных доработок для тестирования правил Ливермора на дневных данных.