English
preview
Автоматизация классических рыночных методов на MQL5 (Часть 6): Система ключевых точек Джесси Ливермора

Автоматизация классических рыночных методов на MQL5 (Часть 6): Система ключевых точек Джесси Ливермора

MetaTrader 5 — Примеры |
30 0
Tola Moses Hector
Tola Moses Hector

Введение

Джесси Ливермор — самый цитируемый трейдер в истории. "Большие деньги мне приносило не мое мышление, а умение выждать". "Рынки никогда не ошибаются — а мнения часто ошибаются". "Большие деньги — не в покупке и продаже, а в умении выждать". Его слова наполняют книги по трейдингу, изданные спустя столетие после того, как он их написал.

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

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

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

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

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

Мы рассмотрим следующие темы:

  1. Рыночный ключ Ливермора: теория и правила
  2. Что считается корректным сигналом в данной реализации
  3. Архитектура — конечный автомат и модуль ключевых уровней
  4. Реализация на языке MQL5
  5. Известные ограничения
  6. Заключение



Рыночный ключ Ливермора: теория и правила

Ливермор описал свой рыночный ключ в книге "Как торговать акциями", вышедшей в 1940 году. Система относит каждый бар к одному из четырех состояний рынка и отслеживает ключевые ценовые уровни — максимальные и минимальные отметки текущей торговой кампании.

Обзор рыночного ключа Ливермора

Рис. 1. Обзор рыночного ключа Ливермора.

Четыре состояния

  1. Восходящий тренд считается активным, если цена пробила ключевой максимум на фоне роста объема торгов и с тех пор не демонстрировала аномального поведения.
  2. Естественная реакция — это ожидаемый откат при низком объеме, следующий за ростом. В ходе реакции объем уменьшается. Это нормально и вполне ожидаемо. Ливермор использовал это как возможность нарастить позицию после завершения естественной реакции и возобновления роста. Реакция, происходящая при высоком объеме, не является естественной — она аномальна, и Ливермор рассматривал ее как сигнал к выходу из рынка.
  3. Естественное ралли — это зеркальное отражение естественной реакции: ожидаемый отскок на низком объеме в рамках нисходящего тренда. Во время ралли объем торгов снижается. Когда ралли заканчивается и цена возобновляет снижение на фоне роста объема торгов, Ливермор увеличивает свою короткую позицию.
  4. Нисходящий тренд считается активным, если цена пробила ключевой минимум на фоне роста объема торгов и с тех пор не демонстрировала аномального поведения.

Четыре состояния рынка

Рис. 2. Четыре состояния рынка.

Ключевая точка

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

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

При пробое цена должна выйти за зафиксированный ключевой уровень как минимум на величину ATR, умноженную на "InpPivotClearATR", а объем бара пробоя должен превышать средний объем консолидации как минимум в InpVolExpansion раз. Пробой, при котором цена едва поднимается выше ключевого уровня на низком объеме, не является сигналом Ливермора.

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

Естественная реакция и возобновление движения

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

Аномальное поведение

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

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

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

Вход с пирамидальным наращиванием позиции

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

  • Транш 1 — это пробный вход: 20 % от планируемого объема позиции. Вход выполняется на баре пробоя. Если рынок сразу же изменит направление, под угрозой окажутся лишь 20 %.
  • Второй транш открывается, когда цена продвигается на величину "InpTranche2ATR" от точки первого входа, что подтверждает продолжение первоначального движения.
  • Третий транш открывается, когда естественная реакция заканчивается и цена возобновляет движение: на баре, который пробивает локальный максимум реакции на фоне роста объема.
  • Четвертый транш доводит позицию до полного объема, когда цена продвигается еще на величину "InpTranche4ATR" от точки входа в третий транш. Он не может открыться на том же баре, что и третий транш: необходимо дождаться как минимум следующего бара.

Сигнал выхода по методу Ливермора: бар с движением против тренда более чем на "InpAbnormalMoveATR" × ATR и объемом выше среднего объема за торговую кампанию более чем в "InpAbnormalVolMult" раз. В этом случае все транши немедленно закрываются. Реакция, сопровождающаяся высоким объемом, а не снижением объема, также служит сигналом к выходу — по определению это аномальное поведение.


Что считается корректным сигналом в данной реализации?

Перед открытием первого транша должны быть выполнены шесть условий.

  1. Условие консолидации: общий диапазон последних "InpConsolBars" завершенных баров должен быть меньше "InpConsolATR" × ATR. Зона немедленно фиксируется: максимум и минимум цены, а также средний объем не обновляются в течение всего ожидания пробоя.
  2. Условие роста объема: объем бара пробоя должен превышать зафиксированный средний объем консолидации в "InpVolExpansion" раз. Значение по умолчанию — 1.2, то есть на 20 % выше среднего.
  3. Условие отступа от ключевого уровня: цена закрытия бара пробоя должна превышать зафиксированный ключевой уровень как минимум на "InpPivotClearATR" × ATR. По умолчанию используется значение 0.3 ATR.
  4. Условие отсутствия разворота: не допускается ситуация, когда максимум бара превышает ключевой уровень, а цена закрытия возвращается ниже него. Это однодневный разворот: максимум выше ключевого уровня, а цена закрытия — ниже него.
  5. Условие режима счета: счет должен быть хеджинговым. Каждый транш представляет собой отдельную позицию со своим тикетом. Неттинговые счета не поддерживают такую архитектуру.
  6. Условия проверки входных параметров: сумма процентных долей траншей должна равняться 100, а все ключевые параметры должны находиться в допустимых диапазонах. Проверка выполняется в функции "OnInit()" до запуска любой другой логики.

Чтобы естественная реакция считалась допустимой, цена должна откатиться от локального максимума как минимум на величину "InpReactionATR", а объем во время реакции должен быть меньше среднего объема за торговую кампанию, умноженного на "InpReactionVolRatio" (по умолчанию 0.8 — объем должен снижаться). Реакции на высоком объеме рассматриваются как аномальное поведение и приводят к закрытию торговой кампании.

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


Архитектура — конечный автомат и модуль ключевых уровней

Советник использует шесть состояний: "STATE_IDLE", "STATE_CONSOLIDATING", "STATE_UPTREND", "STATE_NATURAL_REACTION", "STATE_DOWNTREND" и "STATE_NATURAL_RALLY".

Модуль ключевых уровней работает в состоянии "STATE_IDLE" с помощью функции "LockConsolidation", которая фиксирует зону при первом сканировании, удовлетворяющем заданным условиям, после чего происходит переход в состояние "STATE_CONSOLIDATING". В состоянии "STATE_CONSOLIDATING" зафиксированная зона больше не сканируется — на каждом новом баре выполняется только функция "CheckPivotBreak()". Такая архитектура гарантирует, что цена закрытия бара пробоя всегда сравнивается с фиксированным опорным уровнем, на который сам бар пробоя не может повлиять.

В структуре торговой кампании хранится "full_lots" — полный объем позиции, который рассчитывается один раз при открытии первого транша. Объем каждого последующего транша рассчитывается вызовом функции "TrancheLots(full_lots, pct)". Если рассчитанный объем транша в лотах после округления оказывается меньше минимума, установленного брокером, функция "TrancheLots()" возвращает 0, и транш пропускается — функция никогда не подставляет вместо рассчитанного объема "min_lot" без уведомления и не создает непредусмотренного риска.

Функция "CloseAllUnits()" безусловно перебирает все четыре ячейки, от 0 до 3, проверяя действительность каждого тикета. В качестве границы цикла не используется "units_open" — это предотвращает пропуск позиций при закрытии из-за незаполненных ячеек в массиве тикетов.

Советник предназначен только для хеджинговых счетов. Это проверяется в функции "OnInit", и советник не запускается на неттинговых счетах.


Реализация на языке MQL5

Советник создается по частям.

Подключаемые файлы, перечисления и входные параметры

//+------------------------------------------------------------------+
//|                                                  LivermoreEA.mq5 |
//|                                Copyright 2026, Tola Moses Hector |
//|                                       https://www.mql5.com       |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Tola Moses Hector"
#property link      "https://www.mql5.com"
#property version   "1.00"
#property description "Automating Classic Market Methods in MQL5 Part 6"
#property description "Jesse Livermore Pivotal Point System"
#property description "Market Key states, pyramid entry, abnormal behavior exit"
#property description "Daily timeframe — hedging account required"

#include <Trade\Trade.mqh>

//+------------------------------------------------------------------+
//| Market Key State Machine                                         |
//+------------------------------------------------------------------+
enum ENUM_LV_STATE
  {
   STATE_IDLE,             // No structure active — scanning for consolidation
   STATE_CONSOLIDATING,    // Consolidation zone locked — watching for pivot break
   STATE_UPTREND,          // Pivot broken upward — campaign active long
   STATE_NATURAL_REACTION, // Low-volume pullback within uptrend
   STATE_DOWNTREND,        // Pivot broken downward — campaign active short
   STATE_NATURAL_RALLY     // Low-volume bounce within downtrend
  };

//+------------------------------------------------------------------+
//| Input Parameters                                                 |
//+------------------------------------------------------------------+
input group "=== Pivot Detection ==="
input int    InpConsolBars      = 10;   //--- Minimum bars to form a consolidation zone
input double InpConsolATR       = 2.5;  //--- Maximum consolidation range in ATR units
input double InpVolExpansion    = 1.2;  //--- Volume multiplier required on breakout bar
input double InpPivotClearATR   = 0.3;  //--- Minimum pivot clearance in ATR units

input group "=== Trend and Reaction ==="
input double InpReactionATR     = 1.0;  //--- Minimum reaction depth in ATR to confirm Natural Reaction
input double InpReactionVolRatio= 0.8;  //--- Reaction volume must be below this ratio of campaign avg
input double InpAbnormalVolMult = 1.5;  //--- Volume multiplier that defines abnormal behavior
input double InpAbnormalMoveATR = 1.0;  //--- Move size in ATR that defines abnormal behavior

input group "=== Pyramid Entry ==="
input double InpTranche1Pct     = 20.0; //--- Tranche 1 size as percent of full position
input double InpTranche2Pct     = 20.0; //--- Tranche 2 size as percent of full position
input double InpTranche3Pct     = 20.0; //--- Tranche 3 size as percent of full position
input double InpTranche4Pct     = 40.0; //--- Tranche 4 size as percent of full position (must sum to 100)
input double InpTranche2ATR     = 1.0;  //--- ATR advance from T1 to trigger T2 entry
input double InpTranche4ATR     = 1.0;  //--- ATR advance from T3 to trigger T4 entry

input group "=== Risk ==="
input double InpRiskPercent     = 1.0;  //--- Total position risk as percent of balance
input int    InpATRPeriod       = 14;   //--- ATR period

input group "=== General ==="
input int    InpMagicNumber     = 100601; //--- Magic number
input int    InpSlippage        = 10;    //--- Slippage in points
input bool   InpShowLabels      = true;  //--- Draw labels on chart

Сумма процентных долей по четырем траншам должна составлять 100. Функция "OnInit()" проверяет это условие и не допускает запуска советника, если сумма отличается от 100 более чем на 0.01. Комментарий к "InpTranche1Pct" указывает на это требование на панели входных параметров.

Проверка входных параметров

Функция "ValidateInputs()" запускается до начала любой другой инициализации. Она проверяет сумму процентных долей траншей, диапазоны основных параметров и режим счета.

//+------------------------------------------------------------------+
//| Validates all input parameters before EA start                   |
//+------------------------------------------------------------------+
bool ValidateInputs()
  {
   double tranche_sum = InpTranche1Pct + InpTranche2Pct + InpTranche3Pct + InpTranche4Pct;
   if(MathAbs(tranche_sum - 100.0) > 0.01)
     {
      Print("LivermoreEA: Tranche percentages must sum to 100. Current sum: ", tranche_sum);
      return false;
     }
   if(InpConsolBars < 3)
     { Print("LivermoreEA: InpConsolBars must be >= 3."); return false; }
   if(InpATRPeriod < 2)
     { Print("LivermoreEA: InpATRPeriod must be >= 2."); return false; }
   if(InpRiskPercent <= 0)
     { Print("LivermoreEA: InpRiskPercent must be > 0."); return false; }
   if(InpVolExpansion < 1.0)
     { Print("LivermoreEA: InpVolExpansion must be >= 1.0."); return false; }
   if(InpTranche1Pct <= 0 || InpTranche2Pct <= 0 || InpTranche3Pct <= 0 || InpTranche4Pct <= 0)
     { Print("LivermoreEA: All tranche percentages must be > 0."); return false; }
//--- Require hedging account mode
   if(AccountInfoInteger(ACCOUNT_MARGIN_MODE) != ACCOUNT_MARGIN_MODE_RETAIL_HEDGING)
     {
      Print("LivermoreEA: Hedging account required. This EA uses individual position tickets per tranche.");
      return false;
     }
   return true;
  }

Структура состояния торговой кампании

В структуре хранятся "full_lots" — полный объем позиции, рассчитываемый один раз при открытии транша 1, — и "t3_open_time", который не позволяет открыть транш 4 на том же баре, что и транш 3. Для индексации массива тикетов всегда используются индексы от 0 до 3, а не значение "units_open".

//+------------------------------------------------------------------+
//| Active campaign state                                            |
//+------------------------------------------------------------------+
struct SLivermoreCampaign
  {
   bool     is_long;
   double   pivot_price;
   double   consol_high;        // Frozen consolidation zone high
   double   consol_low;         // Frozen consolidation zone low
   double   avg_consol_vol;     // Frozen consolidation average volume
   double   avg_campaign_vol;   // Running average volume during campaign
   int      campaign_bars;
   int      units_open;
   double   full_lots;          // Computed once at T1 — used by all tranches
   double   entry_prices[4];
   double   lots[4];
   ulong    tickets[4];         // Indexed by slot [0..3] — not by units_open
   double   t1_entry;
   double   t3_entry;
   datetime t3_open_time;       // Bar time T3 opened — prevents T4 on same bar
   bool     t2_open;
   bool     t3_open;
   bool     t4_open;
   double   reaction_high;      // Swing high reference for reaction detection
   double   reaction_low_bar;   // Lowest close reached during Natural Reaction
   double   reaction_avg_vol;   // Average volume during the reaction
   int      reaction_bars;      // Number of bars in the current reaction
  };

Комментарий "Frozen" к полям "consol_high", "consol_low" и "avg_consol_vol" отражает замысел разработчиков: после записи значений в эти три поля функцией "LockConsolidation()" они больше не изменяются до сброса состояния торговой кампании. Бар пробоя всегда оценивается относительно неизменной базы сравнения.

Глобальные переменные

//+------------------------------------------------------------------+
//| Global Variables                                                 |
//+------------------------------------------------------------------+
ENUM_LV_STATE      g_state        = STATE_IDLE;
SLivermoreCampaign g_campaign;
CTrade             g_trade;
int                g_atr_handle   = INVALID_HANDLE;
datetime           g_last_bar     = 0;
int                g_consol_watch = 0;

Вспомогательные функции

//+------------------------------------------------------------------+
//| Returns pip size for the current symbol                          |
//+------------------------------------------------------------------+
double PipSize()
  {
   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   return (digits == 3 || digits == 5) ? _Point * 10.0 : _Point;
  }

//+------------------------------------------------------------------+
//| Computes full-position lot size from risk and stop distance      |
//+------------------------------------------------------------------+
double CalcFullLots(double sl_pips)
  {
   double balance   = AccountInfoDouble(ACCOUNT_BALANCE);
   double risk_amt  = balance * InpRiskPercent / 100.0;
   double tick_val  = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double tick_size = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   double pip_size  = PipSize();
   if(tick_size <= 0 || tick_val <= 0 || sl_pips <= 0)
      return 0;
   double pip_value = (pip_size / tick_size) * tick_val;
   double lots      = risk_amt / (sl_pips * pip_value);
   double step      = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   double min_lot   = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double max_lot   = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   if(step <= 0 || min_lot <= 0 || max_lot <= 0)
      return 0;
   lots = MathFloor(lots / step) * step;
   return MathMax(min_lot, MathMin(max_lot, lots));
  }

//+------------------------------------------------------------------+
//| Returns lot size for a specific tranche from the stored full_lots|
//| Returns 0 — not min_lot — if calculated size is below minimum    |
//+------------------------------------------------------------------+
double TrancheLots(double full_lots, double pct)
  {
   double step    = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   double min_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double max_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   if(step <= 0 || min_lot <= 0 || max_lot <= 0 || full_lots <= 0 || pct <= 0)
      return 0;
   double lots = MathFloor((full_lots * pct / 100.0) / step) * step;
   lots = NormalizeDouble(lots, 2);
   if(lots < min_lot)
      return 0;   // Do not open if below minimum — never substitute min_lot
   if(lots > max_lot)
      lots = max_lot;
   return lots;
  }
Возврат функцией "TrancheLots()" значения 0, когда рассчитанный объем меньше минимально допустимого, — важное решение для обеспечения безопасности торговли. На счетах с небольшим капиталом, где полный объем позиции минимален, объем транша в 20 % после округления может оказаться меньше минимального лота. Подстановка значения "min_lot" привела бы к открытию позиции большего объема, чем предусмотрено моделью риска. Возврат значения 0 позволяет корректно пропустить транш: советник записывает пропуск в журнал и продолжает работу, не открывая позицию незапланированного объема.

Вспомогательные функции для рисования на графике

//+------------------------------------------------------------------+
//| Draws a horizontal line                                          |
//+------------------------------------------------------------------+
void DrawHLine(string name, double price, color clr, ENUM_LINE_STYLE style)
  {
   if(!InpShowLabels)
      return;
   string obj = "LV_" + name;
   ObjectDelete(0, obj);
   ObjectCreate(0, obj, OBJ_HLINE, 0, 0, price);
   ObjectSetInteger(0, obj, OBJPROP_COLOR, clr);
   ObjectSetInteger(0, obj, OBJPROP_STYLE, style);
   ObjectSetInteger(0, obj, OBJPROP_WIDTH, 1);
   ChartRedraw(0);
  }

//+------------------------------------------------------------------+
//| Places a text label                                              |
//+------------------------------------------------------------------+
void DrawLabel(string name, datetime time, double price, string text, color clr)
  {
   if(!InpShowLabels)
      return;
   string obj = "LV_" + name;
   ObjectDelete(0, obj);
   ObjectCreate(0, obj, OBJ_TEXT, 0, time, price);
   ObjectSetString(0,  obj, OBJPROP_TEXT, text);
   ObjectSetInteger(0, obj, OBJPROP_COLOR, clr);
   ObjectSetInteger(0, obj, OBJPROP_FONTSIZE, 9);
   ChartRedraw(0);
  }

//+------------------------------------------------------------------+
//| Removes all chart objects created by this EA                     |
//+------------------------------------------------------------------+
void ClearLabels()
  {
   int total = ObjectsTotal(0);
   for(int i = total - 1; i >= 0; i--)
     {
      string name = ObjectName(0, i);
      if(StringFind(name, "LV_") == 0)
         ObjectDelete(0, name);
     }
   ChartRedraw(0);
  }

//+------------------------------------------------------------------+
//| Resets the campaign structure                                    |
//+------------------------------------------------------------------+
void ResetCampaign()
  {
   g_campaign.is_long          = true;
   g_campaign.pivot_price      = 0;
   g_campaign.consol_high      = 0;
   g_campaign.consol_low       = 0;
   g_campaign.avg_consol_vol   = 0;
   g_campaign.avg_campaign_vol = 0;
   g_campaign.campaign_bars    = 0;
   g_campaign.units_open       = 0;
   g_campaign.full_lots        = 0;
   g_campaign.t1_entry         = 0;
   g_campaign.t3_entry         = 0;
   g_campaign.t3_open_time     = 0;
   g_campaign.t2_open          = false;
   g_campaign.t3_open          = false;
   g_campaign.t4_open          = false;
   g_campaign.reaction_high    = 0;
   g_campaign.reaction_low_bar = 0;
   g_campaign.reaction_avg_vol = 0;
   g_campaign.reaction_bars    = 0;
   g_consol_watch              = 0;
   for(int i = 0; i < 4; i++)
     {
      g_campaign.entry_prices[i] = 0;
      g_campaign.lots[i]         = 0;
      g_campaign.tickets[i]      = 0;
     }
  }

Фиксация зоны консолидации

Функция "LockConsolidation()" однократно просматривает завершенные бары в количестве, заданном параметром "InpConsolBars", и фиксирует зону. Зафиксированные значения не обновляются, пока советник находится в состоянии "STATE_CONSOLIDATING".

//+------------------------------------------------------------------+
//| Locks consolidation zone — called only from STATE_IDLE           |
//+------------------------------------------------------------------+
bool LockConsolidation(double atr)
  {
   double high[], low[];
   long   vol[];
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low,  true);
   ArraySetAsSeries(vol,  true);
   if(CopyHigh(_Symbol,       PERIOD_CURRENT, 1, InpConsolBars, high) < InpConsolBars)
      return false;
   if(CopyLow(_Symbol,        PERIOD_CURRENT, 1, InpConsolBars, low)  < InpConsolBars)
      return false;
   if(CopyTickVolume(_Symbol, PERIOD_CURRENT, 1, InpConsolBars, vol)  < InpConsolBars)
      return false;
   double rh = 0, rl = DBL_MAX, avg_vol = 0;
   for(int i = 0; i < InpConsolBars; i++)
     {
      if(high[i] > rh)
         rh = high[i];
      if(low[i]  < rl)
         rl = low[i];
      avg_vol += (double)vol[i];
     }
   avg_vol /= InpConsolBars;
   double range = rh - rl;
   if(range > atr * InpConsolATR || range <= 0)
      return false;
   g_campaign.consol_high    = rh;
   g_campaign.consol_low     = rl;
   g_campaign.avg_consol_vol = avg_vol;
   Print(StringFormat("LivermoreEA: Zone LOCKED | High:%.5f | Low:%.5f | Range:%.5f | AvgVol:%.0f",
                      rh, rl, range, avg_vol));
   DrawHLine("CONSOL_HIGH", rh, clrSilver, STYLE_DOT);
   DrawHLine("CONSOL_LOW",  rl, clrSilver, STYLE_DOT);
   return true;
  }

Проверка пробоя ключевого уровня

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

//+------------------------------------------------------------------+
//| Checks for pivot breakout against frozen consolidation zone      |
//| Returns 1 bull, -1 bear, 0 none                                  |
//| One-day reversal: high exceeded pivot but bar closed below it    |
//+------------------------------------------------------------------+
int CheckPivotBreak(double atr)
  {
   double close1 = iClose(_Symbol, PERIOD_CURRENT, 1);
   double high1  = iHigh(_Symbol,  PERIOD_CURRENT, 1);
   double low1   = iLow(_Symbol,   PERIOD_CURRENT, 1);
   long   vol1   = iTickVolume(_Symbol, PERIOD_CURRENT, 1);
   double clearance = atr * InpPivotClearATR;
   if((double)vol1 < g_campaign.avg_consol_vol * InpVolExpansion)
      return 0;
//--- Bull breakout: close above consol high plus clearance
   if(close1 > g_campaign.consol_high + clearance)
     {
      //--- One-day reversal: high exceeded pivot but bar closed back below pivot
      //--- This is the correct formulation: high > pivot AND close < pivot
      if(high1 > g_campaign.consol_high && close1 < g_campaign.consol_high)
        {
         Print("LivermoreEA: One-day reversal — high exceeded pivot but closed below it. Rejected.");
         return 0;
        }
      g_campaign.pivot_price = g_campaign.consol_high;
      Print(StringFormat("LivermoreEA: BULL BREAK | Close:%.5f | Pivot:%.5f | Vol:%I64d",
                         close1, g_campaign.pivot_price, vol1));
      return 1;
     }
//--- Bear breakout: close below consol low minus clearance
   if(close1 < g_campaign.consol_low - clearance)
     {
      //--- One-day reversal: low exceeded pivot but closed above it
      if(low1 < g_campaign.consol_low && close1 > g_campaign.consol_low)
        {
         Print("LivermoreEA: One-day reversal (bear) — rejected.");
         return 0;
        }
      g_campaign.pivot_price = g_campaign.consol_low;
      Print(StringFormat("LivermoreEA: BEAR BREAK | Close:%.5f | Pivot:%.5f | Vol:%I64d",
                         close1, g_campaign.pivot_price, vol1));
      return -1;
     }
   return 0;
  }

Открытие транша при пирамидальном наращивании позиции

Функция "OpenTranche()" использует значение "g_campaign.full_lots" через вызов "TrancheLots()" в конечном автомате, а не через новый вызов "CalcFullLots()". Если возвращенный объем в лотах равен 0, транш пропускается с записью в журнал.

//+------------------------------------------------------------------+
//| Opens one pyramid tranche using stored full_lots                 |
//+------------------------------------------------------------------+
bool OpenTranche(int slot, double lots, bool is_long, double sl_price, string label)
  {
   if(lots <= 0)
     {
      Print(StringFormat("LivermoreEA: %s skipped — calculated lots below minimum.", label));
      return false;
     }
   long   stop_lv  = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
   double min_dist = stop_lv * _Point;
   bool   ok       = false;
   if(is_long)
     {
      double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      if(ask - sl_price < min_dist)
         sl_price = NormalizeDouble(ask - min_dist - _Point, _Digits);
      ok = g_trade.Buy(lots, _Symbol, ask, sl_price, 0,
                       "Livermore T" + IntegerToString(slot + 1));
      if(ok)
        {
         g_campaign.entry_prices[slot] = ask;
         g_campaign.lots[slot]         = lots;
         ulong deal = g_trade.ResultDeal();
         if(deal > 0 && HistoryDealSelect(deal))
            g_campaign.tickets[slot] = (ulong)HistoryDealGetInteger(deal, DEAL_POSITION_ID);
         else
            g_campaign.tickets[slot] = g_trade.ResultOrder();
         g_campaign.units_open++;
         datetime t = iTime(_Symbol, PERIOD_CURRENT, 1);
         DrawLabel(label, t,
                   iLow(_Symbol, PERIOD_CURRENT, 1) - PipSize() * 5,
                   label, clrDodgerBlue);
         Print(StringFormat("LivermoreEA: %s | Lots:%.2f | Entry:%.5f | SL:%.5f",
                            label, lots, ask, sl_price));
        }
     }
   else
     {
      double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      if(sl_price - bid < min_dist)
         sl_price = NormalizeDouble(bid + min_dist + _Point, _Digits);
      ok = g_trade.Sell(lots, _Symbol, bid, sl_price, 0,
                        "Livermore T" + IntegerToString(slot + 1));
      if(ok)
        {
         g_campaign.entry_prices[slot] = bid;
         g_campaign.lots[slot]         = lots;
         ulong deal = g_trade.ResultDeal();
         if(deal > 0 && HistoryDealSelect(deal))
            g_campaign.tickets[slot] = (ulong)HistoryDealGetInteger(deal, DEAL_POSITION_ID);
         else
            g_campaign.tickets[slot] = g_trade.ResultOrder();
         g_campaign.units_open++;
         datetime t = iTime(_Symbol, PERIOD_CURRENT, 1);
         DrawLabel(label, t,
                   iHigh(_Symbol, PERIOD_CURRENT, 1) + PipSize() * 5,
                   label, clrOrangeRed);
         Print(StringFormat("LivermoreEA: %s | Lots:%.2f | Entry:%.5f | SL:%.5f",
                            label, lots, bid, sl_price));
        }
     }
   return ok;
  }

Закрытие всех позиций торговой кампании

Функция "CloseAllUnits()" безусловно перебирает все четыре слота. Пропуск слотов с нулевым тикетом позволяет учесть случаи, когда транши были пропущены из-за ограничений по минимальному лоту или вообще не открывались.

//+------------------------------------------------------------------+
//| Closes all open campaign units — iterates all 4 slots            |
//+------------------------------------------------------------------+
void CloseAllUnits(string reason)
  {
   double total_profit = 0;
   for(int i = 3; i >= 0; i--)                    // Always iterate all 4 slots, not units_open
     {
      ulong ticket = g_campaign.tickets[i];
      if(ticket == 0)
         continue;                    // Slot was never filled
      if(!PositionSelectByTicket(ticket))
         continue; // Already closed
      total_profit += PositionGetDouble(POSITION_PROFIT);
      if(!g_trade.PositionClose(ticket))
         Print("LivermoreEA: Close failed | Ticket:", ticket);
     }
   Print(StringFormat("LivermoreEA: Campaign closed | Reason:%s | P&L:%.2f | Units:%d",
                      reason, total_profit, g_campaign.units_open));
   g_state = STATE_IDLE;
   ResetCampaign();
   ClearLabels();
  }

Проверка на наличие аномального поведения

Функция "CheckAbnormalBehavior()" выполняется на каждом баре в ходе активной торговой кампании.

//+------------------------------------------------------------------+
//| Returns true if last bar showed abnormal behavior                |
//+------------------------------------------------------------------+
bool CheckAbnormalBehavior(double atr)
  {
   double close1 = iClose(_Symbol, PERIOD_CURRENT, 1);
   double open1  = iOpen(_Symbol,  PERIOD_CURRENT, 1);
   long   vol1   = iTickVolume(_Symbol, PERIOD_CURRENT, 1);
   double move   = MathAbs(close1 - open1);
   if(move < atr * InpAbnormalMoveATR)
      return false;
   if(g_campaign.avg_campaign_vol <= 0)
      return false;
   if((double)vol1 < g_campaign.avg_campaign_vol * InpAbnormalVolMult)
      return false;
   bool against_trend = (g_campaign.is_long  && close1 < open1) ||
                        (!g_campaign.is_long && close1 > open1);
   if(!against_trend)
      return false;
   Print(StringFormat("LivermoreEA: ABNORMAL BEHAVIOR | Move:%.5f | Vol:%I64d | AvgVol:%.0f",
                      move, vol1, g_campaign.avg_campaign_vol));
   return true;
  }

Конечный автомат

Функция "ProcessStateMachine()" полностью реализует рыночный ключ. Основные изменения по сравнению с предыдущими версиями: значение full_lots сохраняется один раз при открытии T1 и повторно используется для T2–T4; естественная реакция требует снижения объема; возобновление движения требует реального пробоя локального максимума реакции; открытие T4 блокируется на том же баре, на котором открыт T3.
//+------------------------------------------------------------------+
//| Processes the Livermore Market Key state machine for one bar     |
//+------------------------------------------------------------------+
void ProcessStateMachine(double atr)
  {
//--- Update campaign running average volume
   if(g_state == STATE_UPTREND || g_state == STATE_NATURAL_REACTION ||
      g_state == STATE_DOWNTREND || g_state == STATE_NATURAL_RALLY)
     {
      g_campaign.campaign_bars++;
      long vol1 = iTickVolume(_Symbol, PERIOD_CURRENT, 1);
      g_campaign.avg_campaign_vol =
         (g_campaign.avg_campaign_vol * (g_campaign.campaign_bars - 1) + (double)vol1)
         / g_campaign.campaign_bars;
     }

   switch(g_state)
     {
      //--------------------------------------------------------------
      case STATE_IDLE:
         if(LockConsolidation(atr))
           { g_state = STATE_CONSOLIDATING; g_consol_watch = 0; }
         break;

      //--------------------------------------------------------------
      case STATE_CONSOLIDATING:
        {
         g_consol_watch++;
         if(g_consol_watch > InpConsolBars * 3)
           {
            Print("LivermoreEA: Consolidation watch expired — resetting.");
            g_state = STATE_IDLE;
            ResetCampaign();
            ClearLabels();
            break;
           }
         int breakout = CheckPivotBreak(atr);
         if(breakout == 0)
            break;
         bool   is_long  = (breakout == 1);
         //--- Stop placed at the pivot level (opposite side of consolidation)
         //--- This matches the article: stop at pivot = consol_low for longs, consol_high for shorts
         double sl_price = is_long ? g_campaign.consol_low : g_campaign.consol_high;
         double entry_px = is_long ? SymbolInfoDouble(_Symbol, SYMBOL_ASK)
                           : SymbolInfoDouble(_Symbol, SYMBOL_BID);
         double sl_pips  = MathAbs(entry_px - sl_price) / PipSize();
         //--- Compute full_lots ONCE and store in campaign — used by all tranches
         g_campaign.full_lots = CalcFullLots(sl_pips);
         double t1_lots = TrancheLots(g_campaign.full_lots, InpTranche1Pct);
         g_campaign.is_long = is_long;
         if(OpenTranche(0, t1_lots, is_long, sl_price, "T1"))
           {
            g_campaign.t1_entry = g_campaign.entry_prices[0];
            g_campaign.reaction_high = iHigh(_Symbol, PERIOD_CURRENT, 1); // Track swing reference
            DrawHLine("PIVOT", g_campaign.pivot_price, clrOrange, STYLE_DASH);
            DrawHLine("STOP",  sl_price,               clrCrimson, STYLE_DOT);
            g_state = is_long ? STATE_UPTREND : STATE_DOWNTREND;
           }
         else
           { g_state = STATE_IDLE; ResetCampaign(); }
        }
      break;

      //--------------------------------------------------------------
      case STATE_UPTREND:
        {
         if(CheckAbnormalBehavior(atr))
           { CloseAllUnits("Abnormal Behavior"); break; }
         if(iClose(_Symbol, PERIOD_CURRENT, 1) < g_campaign.pivot_price)
           { CloseAllUnits("Pivot Failure"); break; }
         double high1  = iHigh(_Symbol, PERIOD_CURRENT, 1);
         double close1 = iClose(_Symbol, PERIOD_CURRENT, 1);
         //--- Track the running swing high for reaction detection
         if(high1 > g_campaign.reaction_high)
            g_campaign.reaction_high = high1;
         //--- T2: use stored full_lots, not a new CalcFullLots call
         if(!g_campaign.t2_open && close1 >= g_campaign.t1_entry + atr * InpTranche2ATR)
           {
            double lots = TrancheLots(g_campaign.full_lots, InpTranche2Pct);
            if(OpenTranche(1, lots, true, g_campaign.pivot_price, "T2"))
               g_campaign.t2_open = true;
           }
         //--- Natural Reaction: price pulls back InpReactionATR from tracked swing high
         if(g_campaign.reaction_high - close1 > atr * InpReactionATR)
           {
            g_campaign.reaction_low_bar = close1;
            g_campaign.reaction_avg_vol = (double)iTickVolume(_Symbol, PERIOD_CURRENT, 1);
            g_campaign.reaction_bars    = 1;
            g_state = STATE_NATURAL_REACTION;
            Print(StringFormat("LivermoreEA: Natural Reaction started | SwingHigh:%.5f | Close:%.5f",
                               g_campaign.reaction_high, close1));
           }
        }
      break;

      //--------------------------------------------------------------
      case STATE_NATURAL_REACTION:
        {
         if(CheckAbnormalBehavior(atr))
           { CloseAllUnits("Abnormal Behavior During Reaction"); break; }
         if(iClose(_Symbol, PERIOD_CURRENT, 1) < g_campaign.pivot_price)
           { CloseAllUnits("Pivot Failure in Reaction"); break; }
         long   vol1   = iTickVolume(_Symbol, PERIOD_CURRENT, 1);
         double close1 = iClose(_Symbol, PERIOD_CURRENT, 1);
         double high1  = iHigh(_Symbol, PERIOD_CURRENT, 1);
         //--- Track reaction stats
         g_campaign.reaction_bars++;
         g_campaign.reaction_avg_vol =
            (g_campaign.reaction_avg_vol * (g_campaign.reaction_bars - 1) + (double)vol1)
            / g_campaign.reaction_bars;
         if(close1 < g_campaign.reaction_low_bar)
            g_campaign.reaction_low_bar = close1;
         //--- Volume must be contracting (below campaign average) for a genuine reaction
         bool vol_contracting = (g_campaign.avg_campaign_vol <= 0 ||
                                 (double)vol1 < g_campaign.avg_campaign_vol * InpReactionVolRatio);
         if(!vol_contracting)
           {
            //--- High volume during reaction = not a Natural Reaction = abnormal
            Print("LivermoreEA: High volume during reaction — treating as abnormal.");
            CloseAllUnits("High Volume Reaction");
            break;
           }
         //--- Resumption: price breaks above the reaction swing high on expanding volume
         //--- Use the reaction high (highest high during reaction period)
         double reaction_swing_high = g_campaign.reaction_high;
         bool   expanding_vol       = (g_campaign.avg_campaign_vol > 0 &&
                                       (double)vol1 > g_campaign.avg_campaign_vol);
         bool   broke_reaction_high = (high1 > reaction_swing_high);
         if(expanding_vol && broke_reaction_high)
           {
            if(!g_campaign.t3_open)
              {
               double lots = TrancheLots(g_campaign.full_lots, InpTranche3Pct);
               if(OpenTranche(2, lots, true, g_campaign.pivot_price, "T3"))
                 {
                  g_campaign.t3_entry     = g_campaign.entry_prices[2];
                  g_campaign.t3_open_time = iTime(_Symbol, PERIOD_CURRENT, 1);
                  g_campaign.t3_open      = true;
                 }
              }
            //--- Reset reaction high to new high for next reaction detection
            g_campaign.reaction_high = high1;
            g_state = STATE_UPTREND;
            Print("LivermoreEA: Natural Reaction ended — resuming uptrend.");
           }
        }
      break;

      //--------------------------------------------------------------
      case STATE_DOWNTREND:
        {
         if(CheckAbnormalBehavior(atr))
           { CloseAllUnits("Abnormal Behavior"); break; }
         if(iClose(_Symbol, PERIOD_CURRENT, 1) > g_campaign.pivot_price)
           { CloseAllUnits("Pivot Failure"); break; }
         double low1   = iLow(_Symbol,  PERIOD_CURRENT, 1);
         double close1 = iClose(_Symbol, PERIOD_CURRENT, 1);
         if(low1 < g_campaign.reaction_high || g_campaign.reaction_high == 0)
            g_campaign.reaction_high = low1; // Track swing low reference for downtrend
         if(!g_campaign.t2_open && close1 <= g_campaign.t1_entry - atr * InpTranche2ATR)
           {
            double lots = TrancheLots(g_campaign.full_lots, InpTranche2Pct);
            if(OpenTranche(1, lots, false, g_campaign.pivot_price, "T2"))
               g_campaign.t2_open = true;
           }
         //--- Natural Rally: price bounces InpReactionATR from tracked swing low
         double swing_low = g_campaign.reaction_high; // reused field for short campaigns
         if(close1 - swing_low > atr * InpReactionATR)
           {
            g_campaign.reaction_low_bar = close1;
            g_campaign.reaction_avg_vol = (double)iTickVolume(_Symbol, PERIOD_CURRENT, 1);
            g_campaign.reaction_bars    = 1;
            g_state = STATE_NATURAL_RALLY;
            Print("LivermoreEA: Natural Rally started.");
           }
        }
      break;

      //--------------------------------------------------------------
      case STATE_NATURAL_RALLY:
        {
         if(CheckAbnormalBehavior(atr))
           { CloseAllUnits("Abnormal Behavior During Rally"); break; }
         if(iClose(_Symbol, PERIOD_CURRENT, 1) > g_campaign.pivot_price)
           { CloseAllUnits("Pivot Failure in Rally"); break; }
         long   vol1   = iTickVolume(_Symbol, PERIOD_CURRENT, 1);
         double close1 = iClose(_Symbol, PERIOD_CURRENT, 1);
         double low1   = iLow(_Symbol, PERIOD_CURRENT, 1);
         g_campaign.reaction_bars++;
         g_campaign.reaction_avg_vol =
            (g_campaign.reaction_avg_vol * (g_campaign.reaction_bars - 1) + (double)vol1)
            / g_campaign.reaction_bars;
         bool vol_contracting = (g_campaign.avg_campaign_vol <= 0 ||
                                 (double)vol1 < g_campaign.avg_campaign_vol * InpReactionVolRatio);
         if(!vol_contracting)
           { Print("LivermoreEA: High volume during rally — abnormal."); CloseAllUnits("High Volume Rally"); break; }
         double reaction_swing_low = g_campaign.reaction_high; // swing low reference
         bool   expanding_vol      = (g_campaign.avg_campaign_vol > 0 && (double)vol1 > g_campaign.avg_campaign_vol);
         bool   broke_reaction_low = (low1 < reaction_swing_low);
         if(expanding_vol && broke_reaction_low)
           {
            if(!g_campaign.t3_open)
              {
               double lots = TrancheLots(g_campaign.full_lots, InpTranche3Pct);
               if(OpenTranche(2, lots, false, g_campaign.pivot_price, "T3"))
                 {
                  g_campaign.t3_entry     = g_campaign.entry_prices[2];
                  g_campaign.t3_open_time = iTime(_Symbol, PERIOD_CURRENT, 1);
                  g_campaign.t3_open      = true;
                 }
              }
            g_campaign.reaction_high = low1;
            g_state = STATE_DOWNTREND;
            Print("LivermoreEA: Natural Rally ended — resuming downtrend.");
           }
        }
      break;
     }

//--- T4: after T3, further InpTranche4ATR advance — NOT on same bar as T3
   if((g_state == STATE_UPTREND || g_state == STATE_DOWNTREND) &&
      g_campaign.t3_open && !g_campaign.t4_open && g_campaign.t3_entry > 0)
     {
      datetime current_bar_time = iTime(_Symbol, PERIOD_CURRENT, 1);
      if(current_bar_time == g_campaign.t3_open_time)
         return; // Block T4 on same bar as T3
      double close1 = iClose(_Symbol, PERIOD_CURRENT, 1);
      bool t4_ok    = g_campaign.is_long
                      ? close1 >= g_campaign.t3_entry + atr * InpTranche4ATR
                      : close1 <= g_campaign.t3_entry - atr * InpTranche4ATR;
      if(t4_ok)
        {
         double lots = TrancheLots(g_campaign.full_lots, InpTranche4Pct);
         if(OpenTranche(3, lots, g_campaign.is_long, g_campaign.pivot_price, "T4"))
            g_campaign.t4_open = true;
        }
     }
  }

OnInit, OnDeinit и OnTick

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(!ValidateInputs())
      return INIT_FAILED;
   g_atr_handle = iATR(_Symbol, PERIOD_CURRENT, InpATRPeriod);
   if(g_atr_handle == INVALID_HANDLE)
     { Print("LivermoreEA: ATR handle creation failed."); return INIT_FAILED; }
   g_trade.SetExpertMagicNumber(InpMagicNumber);
   g_trade.SetDeviationInPoints(InpSlippage);
   g_state = STATE_IDLE;
   g_last_bar = 0;
   ResetCampaign();
   Print(StringFormat("LivermoreEA v2 initialized | Symbol:%s | TF:%s | Magic:%d",
                      _Symbol, EnumToString(Period()), InpMagicNumber));
   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   IndicatorRelease(g_atr_handle);
   ClearLabels();
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   datetime current_bar = iTime(_Symbol, PERIOD_CURRENT, 0);
   if(current_bar == g_last_bar)
      return;
   g_last_bar = current_bar;
   double atr_buf[];
   ArraySetAsSeries(atr_buf, true);
   if(CopyBuffer(g_atr_handle, 0, 1, 1, atr_buf) < 1)
      return;
   double atr = atr_buf[0];
   ProcessStateMachine(atr);
  }
//+------------------------------------------------------------------+

Чего ожидать

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

По результатам проверки при запуске будет выведено сообщение "LivermoreEA initialized | HedgingMode:OK", подтверждающее успешное прохождение проверки счета. Журнал содержит полную историю событий: фиксацию зоны; подтверждение пробоя с указанием соотношения объемов; открытие каждого транша, включая сохраненное значение full_lots; выявление естественной реакции с подтверждением снижения объема; возобновление движения с подтверждением пробоя локального максимума; а также каждое закрытие с указанием причины.

Если консолидации не найдены, увеличьте значение параметра "InpConsolATR" до 3.0. Если сигналы пробоя не срабатывают, уменьшите значение параметра "InpVolExpansion" до 1.1 или "InpPivotClearATR" до 0.2.

Демонстрация LivermoreEA

Рис. 3. Наглядная демонстрация работы системы.


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

Советник не восстанавливает состояние после перезапуска. Все данные торговой кампании — текущее состояние конечного автомата, тикеты траншей, значение full_lots и ключевой уровень — хранятся в памяти. Если терминал перезапускается при открытых позициях, советник перестает их отслеживать и возвращается в состояние "STATE IDLE". В системе, предназначенной для реальной торговли, эту проблему можно было бы решить, добавив в OnInit() восстановление состояния с поиском открытых позиций по магическому номеру, однако в данной реализации такой возможности нет.

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

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

Механизм запрета открытия T4 на том же баре, что и T3, сравнивает время последнего завершенного бара со значением t3_open_time. Это корректно предотвращает открытие T4 на том же баре, что и T3. Однако, если транш T3 открывается в самом конце сессии с сильным движением цены, а условия открытия T4 выполняются уже на следующем баре, транш T4 откроется на один бар позже T3, как и задумано.

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


Заключение

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

Три архитектурных решения отличают этот советник от более простых реализаций. Зона консолидации фиксируется в момент ее определения — бар пробоя сравнивается с неизменным ориентиром, на который сам не может повлиять. Полный размер позиции рассчитывается один раз при открытии транша 1 и сохраняется — транши 2, 3 и 4 всегда составляют фиксированные процентные доли от этого исходного размера, поэтому совокупный риск при пирамидальном наращивании позиции контролируется как единый показатель. Цикл закрытия позиций в функции "CloseAllUnits()" безусловно перебирает все четыре ячейки — пустые ячейки в массиве тикетов, возникающие из-за пропущенных траншей, никогда не приводят к тому, что какая-либо позиция остается незакрытой.

Весь код был скомпилирован в MetaTrader 5. Скопируйте файл "LivermoreEA.mq5" в папку "MQL5\Experts\" и скомпилируйте его в MetaEditor без дополнительных зависимостей. Рекомендуется для пар EURUSD и GBPUSD на дневном таймфрейме. Перед запуском на реальном счете всегда проводите тестирование на демо-счете.

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

Прикрепленные файлы |
LivermoreEA.mq5 (33.87 KB)
Торговые инструменты MQL5 (Часть 36): Фигуры и аннотации в слое рисования с редактированием меток прямо на холсте Торговые инструменты MQL5 (Часть 36): Фигуры и аннотации в слое рисования с редактированием меток прямо на холсте
Мы добавляем на холст восемь инструментов для рисования фигур и девять инструментов для создания аннотаций, а также реализуем полнофункциональную систему редактирования меток на месте. В статье подробно рассматриваются геометрия, отрисовка со сглаживанием, общие вспомогательные функции для переноса слов и отрисовки текста с суперсэмплингом, а также конечный автомат редактирования, основанный на положении текстового курсора и отвечающий за ввод текста, навигацию и выделение. В результате получается полный и согласованный набор инструментов для аннотирования с редактируемыми метками, который интегрируется в существующий конвейер взаимодействия.
Разработка персонального советника (Часть 3): Управление рисками II — маржа и допустимый риск Разработка персонального советника (Часть 3): Управление рисками II — маржа и допустимый риск
Объем в лотах, рассчитанный по риску, все равно может превышать объем, который позволяет открыть свободная маржа. В статье добавляются лимит использования маржи с применением OrderCalcMargin(), опциональный адаптивный лимит использования маржи, который изменяется в зависимости от уровня маржи счета (ACCOUNT MARGIN LEVEL), и единый блок предторговой проверки, объединяющий ограничения по позициям, расчет объема позиции по риску и проверки маржи. Читатели получат конкретный код, позволяющий предотвратить отклонение ордеров и чрезмерное использование маржи, с понятными сообщениями в журнале при уменьшении объема сделки или отказе от ее открытия.
Особенности написания экспертов Особенности написания экспертов
Написание и тестирование экспертов в торговой системе MetaTrader 4.
Фильтр Калмана для сглаживания цены: точная реализация на MQL5 Фильтр Калмана для сглаживания цены: точная реализация на MQL5
В данной статье реализован скалярный фильтр Калмана для сглаживания цены в MQL5 с использованием стандартной модели локального уровня и точных уравнений прогнозирования и коррекции. В статье объясняется, как шум процесса и шум измерения (Q, R) определяют коэффициент усиления Калмана, два независимо настроенных фильтра объединяются в систему на основе пересечения быстрой и медленной линий, а также приводятся полностью реализованные индикатор и советник. Советник получает данные индикатора через iCustom и торгует по сигналу, подтвержденному правилом устойчивости. Это дает воспроизводимую основу для тестирования и настройки.