KCI Volatility Distance - индикатор для MetaTrader 5

Рис. 1

Рис. 3

Простая настройка параметров

Рис. 2

Руководство по интеграции KCI Volatility Distance в советник (EA)

Существует два основных метода интеграции этого алгоритма в советник (EA). Первый метод (встроенный объектно-ориентированный подход) настоятельно рекомендуется для обеспечения максимальной эффективности использования процессора и сбора наборов данных для машинного обучения. Второй метод (вызов iCustom) подходит для быстрого тестирования прототипов.

Метод 1: Прямое использование через встроенный класс ООП (ультра-легкий)

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

// --- 1. Разместите класс ООП в начале файла EA или подключите его с помощью #include ---
class CKCIDirectionalMatrix
  {
   // (Вставьте здесь полную реализацию класса CKCIDirectionalMatrix)
   // ...
  };

// --- 2. Объявление экземпляра глобального объекта ---
CKCIDirectionalMatrix MatrixEngine;

// Входные параметры EA
input int MatrixPeriod = 14;
input double EntryThreshold = 0.0050; // Пороговое значение силы импульса

// --- 3. Инициализация движка в функции OnInit() ---
int OnInit()
  {
   if(!MatrixEngine.Init(MatrixPeriod))
      return(INIT_PARAMETERS_INCORRECT);

   return(INIT_SUCCEEDED);
  }

// --- 4. Выполнение основной логики в функции OnTick() ---
void OnTick()
  {
   // Подготовка массивов для хранения данных о последних рыночных ценах
   double high[], low[], close[];

   if(CopyHigh(_Symbol, _Period, 0, MatrixPeriod + 2, high) < 0)
      return;

   if(CopyLow(_Symbol, _Period, 0, MatrixPeriod + 2, low) < 0)
      return;

   if(CopyClose(_Symbol, _Period, 0, MatrixPeriod + 2, close) < 0)
      return;

   // Массивы необходимо настроить как временные ряды (индекс 0 = самый последний бар)
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);

   // Рассчитать матрицу выходных данных для последнего закрытого бара (индекс 1)
   double current_matrix_strength = MatrixEngine.Calculate(1, high, low, close);

   // --- A. Модуль машинного обучения / извлечения признаков ---
   // Подайте значение «current_matrix_strength» в вашу нейронную сеть
   // или вектор характеристик ИИ в качестве входной переменной.

   // --- Б. Модуль принятия торговых решений (фильтрация сигналов) ---
   if(current_matrix_strength > EntryThreshold)
     {
      // Проверка импульса пройдена.
      // Тенденция рынка считается достаточно сильной.

      // -> Здесь выполняются ордера на ПОКУПКУ или ПРОДАЖУ в соответствии с
      //    в стратегию вашего советника, ориентированную на определённое направление.

      // -> В качестве альтернативы можно использовать это значение для динамического
      //    настроить интервал «Smart Grid» или другие адаптивные параметры.
     }
  }

Метод 2: Вызов через iCustom()

Если вы выпускаете файл .mq5 индикатора KCI Volatility Distance отдельно и хотите, чтобы советник считывал его через стандартный буфер индикаторов.

Фрагмент кода

// --- 1. Объявить дескриптор индикатора в глобальном пространстве имён ---
int MatrixHandle;

// Входные параметры EA
input int MatrixPeriod = 14;

// --- 2. Создание дескриптора индикатора в функции OnInit() ---
int OnInit()
  {
   // Убедитесь, что имя файла индикатора точно совпадает
   // файл, расположенный в папке «Indicators».
   MatrixHandle = iCustom(_Symbol, _Period, "KCI Volatility Distance", MatrixPeriod);

   if(MatrixHandle == INVALID_HANDLE)
     {
      Print("Failed to load the KCI Volatility Distance indicator.");
      return(INIT_FAILED);
     }

   return(INIT_SUCCEEDED);
  }

// --- 3. Чтение данных из буфера индикатора в функции OnTick() ---
void OnTick()
  {
   double MatrixBuffer[];
   ArraySetAsSeries(MatrixBuffer, true);

   // Получить два последних значения из буфера 0 (линия KCI-VD)
   if(CopyBuffer(MatrixHandle, 0, 0, 2, MatrixBuffer) <= 0)
     {
      Print("Failed to copy matrix buffer data.");
      return;
     }

   // Значение матрицы по последней закрывшейся свече
   double current_matrix_strength = MatrixBuffer[1];

   // Значение матрицы для формирующейся в данный момент свечи (в режиме реального времени)
   double previous_matrix_strength = MatrixBuffer[0];

   // --- Логика принятия торговых решений ---
   if(current_matrix_strength > previous_matrix_strength)
     {
      // «Momentum» расширяется.
      // -> Используйте это в качестве дополнительного подтверждения для
      //    увеличить расстояние до уровня «Тейк-профит».
      //
      // -> В качестве альтернативы можно использовать его для запуска адаптивного
      //    Корректировка трейлинг-стопа.
     }
  }

Учитывая высокоадаптивную и нетребовательную к ресурсам процессора архитектуру KCI Volatility Distance, его потенциал выходит за пределы традиционных визуальных индикаторов. Гибкость кода, основанного на объектно-ориентированном программировании (ООП), позволяет ему служить движком для разнообразных сложных алгоритмических сценариев.

1. Система защиты от «охоты за стопами» (динамические SL и TP)

Внезапные ценовые скачки зачастую являются ловушкой ликвидности (liquidity grab или stop-hunt), а не реальным трендом. Индикатор KCI Volatility Distance способен обнаруживать такие аномалии.

• Логика: если происходит резкий скачок цены, но значения матрицы показывают низкий уровень эффективности (направленности), советник распознает это как потенциальный стоп-хантинг.
• Реализация: вместо того, чтобы выполнять Cut Loss или устанавливать статический SL, советник автоматически расширит зону защиты SL (Dynamic SL) до тех пор, пока волатильность не утихнет, а затем будет искать более оптимальную точку восстановления.

// Пример: обнаружение аномалий волатильности (фильтр против «стоп-хантинга»)
double matrix_value = MatrixEngine.Calculate(1, high, low, close);

// ATR служит базовым ориентиром волатильности
double atr_baseline = iATR(_Symbol, _Period, 14);

// Выявление аномального роста рынка по отношению к ожидаемому диапазону волатильности
if(matrix_value > (atr_baseline * 2.5))
  {
   Print("Warning: Volatility anomaly detected. Quantum SL Defense activated.");

   // Защитные меры:
   // - Запретить открытие новых позиций.
   // - Динамическое увеличение стоп-лосса по открытым позициям
   //   чтобы снизить вероятность возникновения явлений «стоп-хант».
   ModifySLToSafeZone(matrix_value);
  }

2. Адаптивная «умная» сетка и алгоритм усреднения

Одним из недостатков стандартной системы «Грид» является её жёсткое расстояние между уровнями (шаги), что особенно опасно при сильном однонаправленном тренде.

• Логика: преобразует интервалы сетки из статических значений (пунктов) в динамические коэффициенты, умноженные на результат вывода KCI Volatility Distance.
• Реализация: когда рынок находится в боковом тренде (матрица расширяется), расстояние между линиями сетки также увеличивается. Это предотвращает открытие советником слишком большого количества позиций в одной зоне консолидации, что делает его очень безопасным для противостояния просадкам на активах с широкими колебаниями, таких как XAUUSD, BTC или US30.

// Пример: Расчет расстояния в адаптивной сетке
input double GridMultiplier = 1.5;

// Получить последние данные измерения матрицы ориентации
double current_matrix = MatrixEngine.Calculate(0, high, low, close);

// Вычислить шаг адаптивной сетки на основе значения матрицы
// в качестве динамического отражения текущей рыночной конъюнктуры
double dynamic_grid_step = current_matrix * GridMultiplier;

// Открывать новую позицию в сетке только после того, как рынок изменит направление движения
// за пределами динамически рассчитанного порогового значения интервала
if(MathAbs(CurrentPrice - LastOrderPrice) >= dynamic_grid_step)
  {
   // Выполнить следующий ордер по сетке / усреднению
   ExecuteGridOrder();
  }

3. Нормализация признаков для машинного обучения (ML)

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

• Логика: В формуле расстояния волатильности KCI предусмотрен расчет коэффициента эффективности (ER), который естественным образом дает масштабное соотношение от 0 до 1.
• Реализация: Вы можете слегка модифицировать объектно-ориентированный класс, чтобы он возвращал чистые значения ER. Этот массив матричных значений извлекается в массив в качестве очень чистого и свободного от шума обучающего набора данных для Pattern Learner.

//+------------------------------------------------------------------+
//|                                                        KCIVD.mqh |
//|                                   Авторские права 2026, KCI Developer |
//|                         https://www.mql5.com/ru/users/ritzfalih |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, KCI Developer"
#property link      "https://www.mql5.com/ru/users/ritzfalih"
#property version   "1.0"

class CKCIVolatilityDistance
  {
private:
   int               m_kinetic_period;
   double            m_point;

public:
                     CKCIVolatilityDistance(void);
                    ~CKCIVolatilityDistance(void);
   
   bool              Init(const int period);
   double            Calculate(const int index, 
                               const double &high[], 
                               const double &low[], 
                               const double &close[]);
  };

//+------------------------------------------------------------------+
//| Конструктор                                                      |
//+------------------------------------------------------------------+
CKCIVolatilityDistance::CKCIVolatilityDistance(void)
  {
   m_kinetic_period = 14;
   m_point          = _Point;
  }

//+------------------------------------------------------------------+
//| Деструктор                                                       |
//+------------------------------------------------------------------+
CKCIVolatilityDistance::~CKCIVolatilityDistance(void)
  {
  }

//+------------------------------------------------------------------+
//| Инициализация                                                   |
//+------------------------------------------------------------------+
bool CKCIVolatilityDistance::Init(const int period)
  {
   if(period < 2)
     {
      Print("[KCI VD Error] Period must be at least 2");
      return(false);
     }
   m_kinetic_period = period;
   m_point          = _Point;
   if(m_point <= 0) m_point = 0.00001; // Резервный вариант для обеспечения безопасности
   return(true);
     }

//+------------------------------------------------------------------+
//| Основной вычислительный движок (оптимизирован для ЦП и скорости)              |
//| Примечание: массивы должны быть заданы как серии (ArraySetAsSeries = true)      |
//+------------------------------------------------------------------+
double CKCIVolatilityDistance::Calculate(const int index, 
                                         const double &high[], 
                                         const double &low[], 
                                         const double &close[])
  {
   double sum_TR    = 0.0;
   double sum_sq_TR = 0.0;
   double path_length = 0.0;

   // --- 1. Оптимизированное окно цикла без вложенных функций ---
   for(int j = 0; j < m_kinetic_period; j++)
     {
      int curr_idx = index + j;
      
      // Оптимизация скорости сравнения True Range (избегая многоуровневого MathMax)
      double hl = high[curr_idx] - low[curr_idx];
      double hc = MathAbs(high[curr_idx] - close[curr_idx + 1]);
      double lc = MathAbs(low[curr_idx] - close[curr_idx + 1]);
      
      double tr = hl;
      if(hc > tr) tr = hc;
      if(lc > tr) tr = lc;
      
      sum_TR    += tr;
      sum_sq_TR += (tr * tr);

      // Длина пути движения цены закрытия (коэффициент эффективности)
      if(j < m_kinetic_period - 1)
        {
         path_length += MathAbs(close[curr_idx] - close[curr_idx + 1]);
        }
     }

   // --- 2. Расчет коэффициента эффективности ---
   double net_distance = MathAbs(close[index] - close[index + m_kinetic_period - 1]);
   
   if(path_length < net_distance) path_length = net_distance; // Логические ограничения
   if(path_length == 0.0)         path_length = m_point;      // Предотвращение деления на ноль
   
   double efficiency_ratio = net_distance / path_length;

   // --- 3. Расчет стандартного отклонения KCI ---
   double mean_TR  = sum_TR / m_kinetic_period;
   double variance = (sum_sq_TR / m_kinetic_period) - (mean_TR * mean_TR);
   if(variance < 0.0) variance = 0.0; // Коррекция точности чисел с плавающей запятой
   
   double std_TR = MathSqrt(variance);

   // --- 4. Вывод итогового значения KCI VD ---
   return(std_TR * (2.0 - efficiency_ratio));
  }

Файл визуального индикатора (KCI_Volatility_Distance.mq5) --- Другие варианты ---

Сохраните этот код в папке MQL5\Indicators\. Теперь этот индикатор имеет очень лаконичный код, так как он вызывает объектно-ориентированную структуру из вышеуказанного файла .mqh.

Фрагмент кода

//+------------------------------------------------------------------+
//|                                      KCI Volatility Distance.mq5 |
//|                                   Авторские права 2026, KCI Developer |
//|                         https://www.mql5.com/ru/users/ritzfalih |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2026, KCI Developer"
#property link        "https://www.mql5.com/ru/users/ritzfalih"
#property description "KCI Volatility Distance - Indicator Module"
#property indicator_separate_window

#property indicator_buffers 1
#property indicator_plots   1
#property indicator_label1  "KCI-VD"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrGold
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

// Включить Mesin Utama KCIVD
#include <KCIVD.mqh>

// --- Ввод ---
input group "=== KCI Volatility Settings ==="
input int KineticPeriod = 14;   // Период расчета (≥2)

// --- Буфер ---
double KVR_Buffer[];

// Экземпляр глобального объекта
CKCIVolatilityDistance kci_engine;

//+------------------------------------------------------------------+
//| Функция инициализации пользовательского индикатора                         |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(!kci_engine.Init(KineticPeriod))
      return(INIT_PARAMETERS_INCORRECT);

   SetIndexBuffer(0, KVR_Buffer, INDICATOR_DATA);
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, 0.0);
   ArraySetAsSeries(KVR_Buffer, true);

   IndicatorSetInteger(INDICATOR_DIGITS, _Digits);
   IndicatorSetString(INDICATOR_SHORTNAME, "KCI-VD(" + IntegerToString(KineticPeriod) + ")");

   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Функция итерации пользовательского индикатора                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   if(rates_total < KineticPeriod + 2) return(0);

   // Настроить встроенный массив в качестве ряда
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);

   if(prev_calculated == 0)
     {
      ArrayInitialize(KVR_Buffer, 0.0);
     }

   int limit = (prev_calculated == 0) ? (rates_total - KineticPeriod - 2) : (rates_total - prev_calculated + 1);

   // Запустить вычислительную машину с помощью объекта ООП
   for(int i = limit; i >= 0 && !IsStopped(); i--)
     {
      KVR_Buffer[i] = kci_engine.Calculate(i, high, low, close);
     }

   return(rates_total);
  }

Руководство по межфункциональной интеграции (как использовать в советниках/ML)

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

Интеграция в модуль машинного обучения (извлечение признаков / валидация сигналов)

Если у вас есть модуль нейронной сети или модуль обучения по шаблонам, который требует нормализации волатильности в качестве входной характеристики, вы можете извлечь значение KCI VD следующим образом:

Фрагмент кода

#include <KCIVD.mqh>

CKCIVolatilityDistance KCI_ML;

int OnInit()
  {
   // Инициализация модуля KCI Volatility Distance
   // с указанием желаемого периода расчета.
   KCI_ML.Init(14);

   return(INIT_SUCCEEDED);
  }

void GetMLFeatures()
  {
   double high[], low[], close[];

   // Скопировать достаточное количество исторических данных о ценах
   // (например, последние 50 баров) в локальные массивы.
   CopyHigh(_Symbol, _Period, 0, 50, high);
   CopyLow(_Symbol, _Period, 0, 50, low);
   CopyClose(_Symbol, _Period, 0, 50, close);

   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);

   // Рассчитать значение показателя «KCI Volatility Distance» для
   // текущий бар (индекс 0) или последний закрытый бар (индекс 1).
   double kci_current_volatility = KCI_ML.Calculate(0, high, low, close);

   // Подавать данные из «kci_current_volatility» в нейронную сеть
   // вектор признаков для проверки или прогнозирования сигнала.
  }

4. Сканер нескольких символов (индикатор панели инструментов)

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

• Алгоритм: установите один индикатор панели инструментов на один график, но запустите цикл вычисления матрицы одновременно для 20–30 различных символов.
• Реализация: Индикатор просканирует весь список «Market Watch» (основные валюты, кросс-пары, металлы, индексы) для выявления активов, значения матрицы которых сжимаются (готовится прорыв) или демонстрируют сильный трендовый импульс. Это предотвратит задержки на VPS с Windows Server и перегрузку процессора.

// Пример: механизм сканирования рынка различных активов
string symbols[] = {"EURUSD", "GBPUSD", "XAUUSD", "BTCUSD", "US30"};

for(int s = 0; s < ArraySize(symbols); s++)
  {
   // Загрузить необходимые исторические рыночные данные
   // для текущего торгового инструмента.
   // ...

   // Определить направление и силу
   // последней закрывшейся свечи.
   double strength = MatrixEngine.Calculate(1, h, l, c);

   // Генерировать торговый сигнал только тогда, когда
   // направление силы превышает заданный порог.
   if(strength > Threshold)
     {
      // Обновить панель мониторинга с учетом обнаруженных
      // Возможность ПОКУПКИ/ПРОДАЖИ данного инструмента.
      DrawDashboardSignal(symbols[s], strength);
     }
  }

Это код KCI Volatility Distance; по крайней мере, этот код можно использовать для различных целей. Вы можете доработать его с помощью стандартных индикаторов MT5 и пользовательских индикаторов MT5 для достижения ещё большей точности и тщательного анализа.