Рыночные секреты Ларри Уильямса (Часть 1): Создание индикатора свинговой структуры рынка в MQL5

MetaTrader 5 — Индикаторы | 22 июня 2026, 12:26

Введение

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

В этой статье мы создаем индикатор рыночной структуры на MQL5. Он основан на идеях Ларри Уильямса о рыночных свингах. Индикатор обнаруживает краткосрочные свинговые точки. Он группирует их в среднесрочные и долгосрочные точки. Это позволяет наглядно увидеть, как движется цена.

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

Кто такой Ларри Уильямс?

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

Ларри Уильямс получил широкое признание после победы в World Cup Championship of Futures Trading в 1987 году. В этом соревновании он за двенадцать месяцев превратил десять тысяч долларов ($10000) в более чем один миллион долларов ($1000000). Никто до сих пор не побил этот рекорд. Десять лет спустя его дочь Мишель Уильямс приняла участие в том же соревновании и также победила. Это показало, что его подход можно изучить и успешно применять другим трейдерам.

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

Понимание логики рыночной структуры Уильямса

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

Ларри Уильямс делит свинговые точки на три группы. Это краткосрочные, среднесрочные, и долгосрочные свинги. Каждая группа строится на основе нижестоящей, что позволяет видеть формирование структуры слой за слоем. С помощью нескольких правил мы можем анализировать графики последовательно и структурированно.

Краткосрочные свинги

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

краткосрочный минимум

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

краткосрочный максимум

Среднесрочные свинги

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

среднесрочный максимум

Аналогично, среднесрочный минимум формируется, когда с обеих сторон от краткосрочного минимума находятся более высокие краткосрочные минимумы.

среднесрочный минимум

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

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

Долгосрочные свинги

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

долгосрочный максимум

Долгосрочный минимум формируется, когда окружающие среднесрочные минимумы находятся выше него.

долгосрочный минимум

Такие долгосрочные свинги часто показывают основные точки разворота рынка.

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

Дизайн индикатора и визуальная структура

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

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

1. Краткосрочные свинговые точки

Краткосрочные точки разворота будут отмечены одиночными кругами.

краткосрочные отметки

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

2. Среднесрочные свинговые точки

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

среднесрочные отметки

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

3. Долгосрочные свинговые точки

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

долгосрочные отметки

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

Реализация логики рыночной структуры в MQL5

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

Для начала откройте MetaEditor 5, создайте новый файл индикатора и назовите его:

larryWilliamsMarketStructureIndicator.mq5

После создания файла удалите все содержимое файла и вставьте следующий стартовый код:

//+------------------------------------------------------------------+
//|                        larryWilliamsMarketStructureIndicator.mq5 |
//|          Copyright 2025, MetaQuotes Ltd. Developer is Chacha Ian |
//|                          https://www.mql5.com/en/users/chachaian |
//+------------------------------------------------------------------+

#property copyright "Copyright 2025, MetaQuotes Ltd. Developer is Chacha Ian"
#property link      "https://www.mql5.com/en/users/chachaian"
#property version   "1.00"

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit(){

   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t  rates_total,
                const int32_t  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 int32_t  &spread[])
{
   //--- Return total bars processed
   return(rates_total);
}

//--- UTILITY FUNCTIONS

//+------------------------------------------------------------------+

Разбор кода

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

1. Заголовок файла

//+------------------------------------------------------------------+
//|                        larryWilliamsMarketStructureIndicator.mq5 |
//|          Copyright 2025, MetaQuotes Ltd. Developer is Chacha Ian |
//|                          https://www.mql5.com/en/users/chachaian |
//+------------------------------------------------------------------+

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

2. Объявления свойств

Строки #property ниже задают метаданные индикатора.

#property copyright "Copyright 2025, MetaQuotes Ltd. Developer is Chacha Ian"
#property link      "https://www.mql5.com/en/users/chachaian"
#property version   "1.00"

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

3. OnInit функция

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit(){

   return(INIT_SUCCEEDED);
}

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

4. OnCalculate функция

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t  rates_total,
                const int32_t  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 int32_t  &spread[])
{
   //--- Return total bars processed
   return(rates_total);
}

Эта функция выполняется каждый раз, когда график обновляется или формируется новая свеча. Она получает массивы цен (Open, High, Low, Close) и возвращает количество обработанных баров. Скоро мы добавим сюда всю логику обнаружения свингов: краткосрочных, среднесрочных и долгосрочных.

5. Раздел служебных функций

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

Теперь, когда файл проекта подготовлен, следующий шаг — указать MetaTrader 5, где должен отображаться наш индикатор. Каждый индикатор должен указать, будет ли он отображаться в главном окне графика или в отдельном подокне. К индикаторам, отображаемым в отдельном подокне, относятся такие инструменты, как RSI и MACD, а индикаторы, строящиеся по цене, например скользящие средние, обычно отображаются прямо на графике.

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

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

//+------------------------------------------------------------------+
//| Custom Indicator specific directives                             |
//+------------------------------------------------------------------+
#property indicator_chart_window

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

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

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

Краткосрочный минимум
Краткосрочный максимум
Среднесрочный минимум
Среднесрочный максимум
Долгосрочный минимум
Долгосрочный максимум

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

//+------------------------------------------------------------------+
//| Custom Indicator specific directives                             |
//+------------------------------------------------------------------+

...

#property indicator_plots 6
#property indicator_buffers 6

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

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

//+------------------------------------------------------------------+
//| Indicator buffers                                                |
//+------------------------------------------------------------------+
double shortTermLows [];
double shortTermHighs[];

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

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

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

Добавьте следующий код внутрь OnInit функции:

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit(){

   //--- Bind arrays to indicator buffers
   SetIndexBuffer(0, shortTermLows,  INDICATOR_DATA);
   SetIndexBuffer(1, shortTermHighs, INDICATOR_DATA);

   return(INIT_SUCCEEDED);
}

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

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

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

Теперь обновите функцию OnCalculate, чтобы она соответствовала структуре ниже.

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t  rates_total,
                const int32_t  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 int32_t  &spread[])
{
   //--- Start with clean buffers at first calculation
   if(prev_calculated == 0){
   }
   
   //--- Recalculate structures only when a new bar is added
   if(prev_calculated < rates_total){
   }

   //--- Return total bars processed
   return(rates_total);
}

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

Для этого мы добавляем логику инициализации внутрь блока, который проверяет prev_calculated == 0. Этот блок выполняется только один раз, когда индикатор впервые прикрепляется к графику. Здесь мы используем функцию ArrayInitialize, чтобы заполнить оба массива значением EMPTY_VALUE. EMPTY_VALUE — это специальное значение, которое сообщает MetaTrader 5, что на данном баре ничего рисовать не нужно.

Обновите код, чтобы он соответствовал структуре ниже:

//--- Start with clean buffers at first calculation
   if(prev_calculated == 0){
   
      ArrayInitialize(shortTermLows,  EMPTY_VALUE);
      ArrayInitialize(shortTermHighs, EMPTY_VALUE);
      
   }

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

Обнаружение краткосрочных свинговых точек в OnCalculate

   //--- Recalculate structures only when a new bar is added
   if(prev_calculated < rates_total){

      ArrayInitialize(shortTermLows,  EMPTY_VALUE);
      ArrayInitialize(shortTermHighs, EMPTY_VALUE);
      
      for(int32_t i = 1; i < rates_total - 2; i++){
         //--- Identify a short-term low
         if(low[i] < low[i - 1] && low[i] < low[i + 1]){
            shortTermLows[i] = low[i];
         }
         
         //--- Identify a short-term high
         if(high[i] > high[i - 1] && high[i] > high[i + 1]){
            shortTermHighs[i] = high[i];
         }
      }   
   }

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

Ниже объясняется, что делает каждая часть и зачем она нужна

ArrayInitialize(shortTermLows,  EMPTY_VALUE);
ArrayInitialize(shortTermHighs, EMPTY_VALUE);

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

for(int32_t i = 1; i < rates_total - 2; i++){
}

Цикл проходит по каждому допустимому индексу бара. Мы начинаем с единицы, потому что нужен левый сосед с индексом i-1. Мы заканчиваем до последних баров, чтобы правый сосед с индексом i+1 всегда существовал. Это предотвращает чтение за пределами массива и позволяет избежать ошибок.

Внутри цикла мы применяем проверки по трем барам.

if(low[i] < low[i - 1] && low[i] < low[i + 1]){
    shortTermLows[i] = low[i];
 }

Это проверка краткосрочного минимума. Если условие равно true, мы записываем цену минимума в shortTermLows буфер с индексом i. Запись реальной цены в буфер заставляет систему построения нарисовать символ для этого бара.

//--- Identify a short-term high
if(high[i] > high[i - 1] && high[i] > high[i + 1]){
   shortTermHighs[i] = high[i];
}

Это проверка краткосрочного максимума. Если она проходит, мы записываем цену максимума в shortTermHighs буфер с индексом i. Запись значения заставляет график показать отметку максимума для этого бара.

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

Настройка графических построений для краткосрочных свинговых точек

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

Мы добавим два построения. Одно будет показывать краткосрочные минимумы, другое — краткосрочные максимумы. Оба построения будут использовать круглый символ Wingdings. Ларри Уильямс часто описывает эти точки как «окольцованные» свинги, поэтому круглый символ подходит идеально.

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

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit(){
   ...
   
   //--- Configure Graphic Plots   
   PlotIndexSetInteger(0, PLOT_DRAW_TYPE, DRAW_ARROW);
   PlotIndexSetInteger(0, PLOT_ARROW, 161);
   PlotIndexSetDouble (0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetString (0, PLOT_LABEL, "ShortTermLows");
   
   PlotIndexSetInteger(1, PLOT_DRAW_TYPE, DRAW_ARROW);
   PlotIndexSetInteger(1, PLOT_ARROW, 161);
   PlotIndexSetDouble (1, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetString (1, PLOT_LABEL, "ShortTermHighs");

   return(INIT_SUCCEEDED);
}

Разберем, что делает каждая строка.

PlotIndexSetInteger(0, PLOT_DRAW_TYPE, DRAW_ARROW);

...

PlotIndexSetInteger(1, PLOT_DRAW_TYPE, DRAW_ARROW);

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

PlotIndexSetInteger(0, PLOT_ARROW, 161);

...

PlotIndexSetInteger(1, PLOT_ARROW, 161);

Здесь мы выбираем код символа Wingdings. Код 161 — это круглый символ, который выглядит на графике как аккуратное кольцо. Он соответствует визуальному стилю, который Ларри Уильямс использует для свинговых точек.

PlotIndexSetDouble (0, PLOT_EMPTY_VALUE, EMPTY_VALUE);

...

PlotIndexSetDouble (1, PLOT_EMPTY_VALUE, EMPTY_VALUE);

Это сообщает MetaTrader 5, что означает «ничего не рисовать». Поскольку мы инициализируем неиспользуемые бары значением EMPTY_VALUE, индикатор будет рисовать символ только на тех барах, где мы записываем в буфер реальную цену.

PlotIndexSetString (0, PLOT_LABEL, "ShortTermLows");

...

PlotIndexSetString (1, PLOT_LABEL, "ShortTermHighs");

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

Для завершения настройки нужно также управлять внешним видом построений с помощью директив свойств. Добавьте эти строки сразу под существующими #property директивами:

#property indicator_color1 clrGreen
#property indicator_color2 clrBlack

#property indicator_width1 1
#property indicator_width2 1

Вот что делают эти директивы:

indicator_color1 и indicator_color2

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

indicator_width1 и indicator_width2

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

На этом этапе индикатор уже имеет базовую логику определения, регистрацию буферов и настройку построений. Он готов к первой проверке. Сохраните файл, нажмите Compile в MetaEditor 5 и убедитесь, что ошибок нет. Затем прикрепите индикатор к любому графику. Используйте таймфрейм с достаточным количеством баров, например дневной или H1. После загрузки обратите внимание, как на графике появляются небольшие круги. Эти круги отмечают краткосрочные свинговые минимумы и максимумы. Прокрутите историю или дождитесь формирования нового бара — вы должны увидеть, как свинговые точки обновляются автоматически.

краткосрочные свинговые точки

Построение среднесрочных свинговых точек

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

double intermediateTermLows [];
double intermediateTermHighs[];

Внутри OnInit функции мы связываем эти массивы с новыми индексами индикаторных буферов, вызывая SetIndexBuffer. Это гарантирует, что MetaTrader 5 знает, откуда будут поступать значения для этих построений.

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit(){

   ...
   
   SetIndexBuffer(2, intermediateTermLows,  INDICATOR_DATA);
   SetIndexBuffer(3, intermediateTermHighs, INDICATOR_DATA);
   
   ...

   return(INIT_SUCCEEDED);
}

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

//+------------------------------------------------------------------+
//| Build intermediate highs from short-term highs                   |
//+------------------------------------------------------------------+
void BuildIntermediateHighs(const double &shortHighs[], const int32_t rates_total, double &intermediateHighs[])
{
   // ensure target array sized
   if(ArraySize(intermediateHighs) != rates_total) ArrayResize(intermediateHighs, rates_total);

   // clear intermediate buffer
   for(int32_t i = 0; i < rates_total; ++i) intermediateHighs[i] = EMPTY_VALUE;

   // collect indices of short-term highs
   int SH_idx[];
   ArrayResize(SH_idx, 0);
   for(int32_t i = 0; i < rates_total; ++i)
   {
      if(shortHighs[i] != EMPTY_VALUE)
      {
         int newlen = ArraySize(SH_idx) + 1;
         ArrayResize(SH_idx, newlen);
         SH_idx[newlen - 1] = i;
      }
   }

   // compress: each short high with lower short highs on both sides becomes an intermediate high
   int count = ArraySize(SH_idx);
   if(count < 3) return; // need at least three short-highs for a middle one to qualify

   for(int k = 1; k < count - 1; ++k)
   {
      int prev_i = SH_idx[k - 1];
      int cur_i  = SH_idx[k];
      int next_i = SH_idx[k + 1];

      // strict comparison per Larry: current must be higher than neighbors
      if(shortHighs[cur_i] > shortHighs[prev_i] && shortHighs[cur_i] > shortHighs[next_i])
         intermediateHighs[cur_i] = shortHighs[cur_i];
   }
}

//+------------------------------------------------------------------+
//| Build intermediate lows from short-term lows                     |
//+------------------------------------------------------------------+
void BuildIntermediateLows(const double &shortLows[], const int32_t rates_total, double &intermediateLows[])
{
   if(ArraySize(intermediateLows) != rates_total) ArrayResize(intermediateLows, rates_total);

   for(int32_t i = 0; i < rates_total; ++i) intermediateLows[i] = EMPTY_VALUE;

   int SL_idx[];
   ArrayResize(SL_idx, 0);
   for(int32_t i = 0; i < rates_total; ++i)
   {
      if(shortLows[i] != EMPTY_VALUE)
      {
         int newlen = ArraySize(SL_idx) + 1;
         ArrayResize(SL_idx, newlen);
         SL_idx[newlen - 1] = i;
      }
   }

   int count = ArraySize(SL_idx);
   if(count < 3) return;

   for(int k = 1; k < count - 1; ++k)
   {
      int prev_i = SL_idx[k - 1];
      int cur_i  = SL_idx[k];
      int next_i = SL_idx[k + 1];

      // strict comparison: current low must be lower than neighbors
      if(shortLows[cur_i] < shortLows[prev_i] && shortLows[cur_i] < shortLows[next_i])
         intermediateLows[cur_i] = shortLows[cur_i];
   }
}

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

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

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

//--- Start with clean buffers at first calculation
if(prev_calculated == 0){
      
   ...
      
   ArrayInitialize(intermediateTermLows,  EMPTY_VALUE);
   ArrayInitialize(intermediateTermHighs, EMPTY_VALUE);

}

После завершения инициализации можно рассчитать среднесрочные свинговые точки. Это выполняется внутри блока, который срабатывает при формировании нового бара или при первой загрузке индикатора. Иными словами, это происходит, когда prev_calculated меньше rates_total. Мы уже используем этот блок для расчета краткосрочных свинговых точек, поэтому добавляем вызовы функций ниже этого раздела.

//--- Recalculate structures only when a new bar is added
if(prev_calculated < rates_total){
      
   ...
      
   BuildIntermediateLows(shortTermLows, rates_total, intermediateTermLows);
   BuildIntermediateHighs(shortTermHighs, rates_total, intermediateTermHighs);
   
}

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

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

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit(){

   ...
   
   PlotIndexSetInteger(2, PLOT_DRAW_TYPE, DRAW_ARROW);
   PlotIndexSetInteger(2, PLOT_ARROW, 161);
   PlotIndexSetDouble (2, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetString (2, PLOT_LABEL, "intermediateTermLows");
   
   PlotIndexSetInteger(3, PLOT_DRAW_TYPE, DRAW_ARROW);
   PlotIndexSetInteger(3, PLOT_ARROW, 161);
   PlotIndexSetDouble (3, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetString (3, PLOT_LABEL, "IntermediateTermHighs");

   return(INIT_SUCCEEDED);
}

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

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

#property indicator_color3 clrGreen
#property indicator_color4 clrBlack

#property indicator_width3 4
#property indicator_width4 4

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

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

среднесрочные свинговые точки

Построение долгосрочных свинговых точек

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

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

double longTermLows [];
double longTermHighs[];

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

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit(){

   ...
   
   SetIndexBuffer(4, longTermLows,  INDICATOR_DATA);
   SetIndexBuffer(5, longTermHighs, INDICATOR_DATA);
   
   ...

   return(INIT_SUCCEEDED);
}

При первом запуске индикатора мы подготавливаем эти буферы, заполняя их значением EMPTY_VALUE внутри prev_calculated == 0 блока. Это гарантирует, что будут отображаться только реальные долгосрочные свинговые точки:

//--- Start with clean buffers at first calculation
if(prev_calculated == 0){
   
   ...
   
   ArrayInitialize(longTermLows,  EMPTY_VALUE);
   ArrayInitialize(longTermHighs, EMPTY_VALUE);
            
}

Логика вывода долгосрочных свинговых точек почти полностью повторяет то, что мы уже реализовали. Мы по-прежнему используем те же функции построения — BuildIntermediateLows и BuildIntermediateHighs. Единственное отличие состоит в том, что на этом этапе вместо краткосрочных свингов мы передаем на вход среднесрочные. Это позволяет тому же алгоритму определять долгосрочные разворотные точки, используя данные следующего уровня. Внутри блока, отвечающего за пересчет, вызовы выглядят так:

//--- Recalculate structures only when a new bar is added
if(prev_calculated < rates_total){

   ...
      
   BuildIntermediateLows(intermediateTermLows, rates_total, longTermLows);
   BuildIntermediateHighs(intermediateTermHighs, rates_total, longTermHighs);
   
}

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

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

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit(){

   ...
   
   PlotIndexSetInteger(4, PLOT_DRAW_TYPE, DRAW_ARROW);
   PlotIndexSetInteger(4, PLOT_ARROW, 233);
   PlotIndexSetInteger(4, PLOT_ARROW_SHIFT, +30);
   PlotIndexSetDouble (4, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetString (4, PLOT_LABEL, "LongTermHighs");
   
   PlotIndexSetInteger(5, PLOT_DRAW_TYPE, DRAW_ARROW);
   PlotIndexSetInteger(5, PLOT_ARROW, 234);
   PlotIndexSetInteger(5, PLOT_ARROW_SHIFT, -30);
   PlotIndexSetDouble (5, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetString (5, PLOT_LABEL, "LongTermHighs");

   return(INIT_SUCCEEDED);
}

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

#property indicator_color5 clrGreen
#property indicator_color6 clrBlack

#property indicator_width5 2
#property indicator_width6 2

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

Чтобы индикатор всегда отображался четко, мы определяем небольшую служебную функцию ConfigureChartAppearance.

//+------------------------------------------------------------------+
//| This function configures the chart's appearance.                 |
//+------------------------------------------------------------------+
bool ConfigureChartAppearance()
{
   if(!ChartSetInteger(0, CHART_COLOR_BACKGROUND, clrWhite)){
      Print("Error while setting chart background, ", GetLastError());
      return false;
   }
   
   if(!ChartSetInteger(0, CHART_SHOW_GRID, false)){
      Print("Error while setting chart grid, ", GetLastError());
      return false;
   }
   
   if(!ChartSetInteger(0, CHART_MODE, CHART_CANDLES)){
      Print("Error while setting chart mode, ", GetLastError());
      return false;
   }

   if(!ChartSetInteger(0, CHART_COLOR_FOREGROUND, clrBlack)){
      Print("Error while setting chart foreground, ", GetLastError());
      return false;
   }

   if(!ChartSetInteger(0, CHART_COLOR_CANDLE_BULL, clrSeaGreen)){
      Print("Error while setting bullish candles color, ", GetLastError());
      return false;
   }
      
   if(!ChartSetInteger(0, CHART_COLOR_CANDLE_BEAR, clrBlack)){
      Print("Error while setting bearish candles color, ", GetLastError());
      return false;
   }
   
   if(!ChartSetInteger(0, CHART_COLOR_CHART_UP, clrSeaGreen)){
      Print("Error while setting bearish candles color, ", GetLastError());
      return false;
   }
   
   if(!ChartSetInteger(0, CHART_COLOR_CHART_DOWN, clrBlack)){
      Print("Error while setting bearish candles color, ", GetLastError());
      return false;
   }
   
   return true;
}

Эта функция настраивает график в простой высококонтрастный вид: задает белый фон, отключает сетку и применяет единые цвета переднего плана и свечей. Здесь мы не изменяем торговую логику; функция только стандартизирует график, чтобы свинговые построения сразу выделялись при загрузке индикатора.

После определения функции мы вызываем ее в самом начале OnInit функции.

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit(){

   //--- To configure the chart's appearance
   if(!ConfigureChartAppearance()){
      Print("Error while configuring chart appearance", GetLastError());
      return INIT_FAILED;
   }
   
   ...
   
}

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

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

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

долгосрочные свинговые точки

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

Как использовать индикатор в торговле

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

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

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

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

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

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

Заключение

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

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

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

Прикрепленные файлы |

Загрузить ZIP

larryWilliamsMarketStructureIndicator.mq5 (10.64 KB)

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

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

Chacha Ian Maroa

I’m a financial markets trader and MQL5 developer focused on building professional trading solutions for MetaTrader 5.

1. Custom Expert Advisors.
2. Indicators.
3. Trade management tools.
4. Dashboards.
5. Automation systems.

My work emphasises reliability, clean architecture, and practical trading functionality, while I continue to expand into AI and machine learning for algorithmic trading.

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

Последние комментарии | Перейти к обсуждению на форуме трейдеров (4)

Yusuf Yahaya | 20 дек. 2025 в 23:30

Не могли бы вы также написать код для курсов «CRT» и «ICT ALGO»?

Chacha Ian Maroa | 21 дек. 2025 в 07:19

Yusuf Yahaya #:

Можете ли вы также написать код для CRT и ICT ALGO?

Спасибо за внимание. Сейчас я сосредоточен на концепциях Ларри Уильямса, но алгоритмы CRT и ICT — это интересные области, которыми я, возможно, займусь в будущем.

Mfoka Gatsheni | 3 янв. 2026 в 05:42

Если позволите, я бы хотел спросить: стрелка отображается на текущей свече, и, как я понимаю, это индекс [0], верно?

Pegaso | 8 янв. 2026 в 09:46

Это индикатор перекраски?

Создание профессиональной торговой системы на основе Heikin Ashi (Часть 1): Разработка пользовательского индикатора

Эта статья — первая часть серии из двух материалов, предназначенной для освоения практических навыков и лучших практик написания пользовательских индикаторов на MQL5. На практическом примере Heikin Ashi в статье рассматривается теория графиков Heikin Ashi, объясняется, как рассчитываются свечи Heikin Ashi, и показывается их применение в техническом анализе. Центральная часть материала — пошаговое руководство по разработке полнофункционального индикатора Heikin Ashi с нуля, с понятными пояснениями, которые помогают читателям разобраться, что именно писать в коде и почему. Эти базовые знания подготовят почву для второй части, где мы создадим советник, торгующий на основе логики Heikin Ashi.

Знакомство с языком MQL5 (Часть 43): Руководство для начинающих по работе с файлами в MQL5 (V)

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

Разработка торговой стратегии с использованием подхода Volume Boundary

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

Разработка инструментария для анализа Price Action (Часть 64): Синхронизация вручную построенных трендовых линий с автоматическим мониторингом

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