KCI Volatility Distance - indicador para MetaTrader 5

Figura 1

Figura 3

Configurações simples de parâmetros

Fig. 2

Guia de integração do KCI Volatility Distance no Expert Advisor (EA)

Existem dois métodos principais para integrar esse algoritmo a um EA. O primeiro método (OOP incorporado) é altamente recomendado para obter a máxima eficiência da CPU e para a coleta de conjuntos de dados de aprendizado de máquina. O segundo método (invocação iCustom) é adequado para testes rápidos de protótipos.

Método 1: Uso direto por meio da classe OOP incorporada (ultraleve)

• Este método incorpora o mecanismo diretamente no EA sem chamar indicadores externos. O código é colocado no nível global, inicializado em OnInit e executado em OnTick.

// --- 1. Coloque a classe OOP no início do arquivo EA ou inclua-a por meio de #include ---
class CKCIDirectionalMatrix
  {
   // (Insira aqui a implementação completa da classe CKCIDirectionalMatrix)
   // ...
  };

// --- 2. Declarar a instância do objeto global ---
CKCIDirectionalMatrix MatrixEngine;

// Parâmetros de entrada do EA
input int MatrixPeriod = 14;
input double EntryThreshold = 0.0050; // Limite de intensidade do momentum

// --- 3. Inicializar o Engine em OnInit() ---
int OnInit()
  {
   if(!MatrixEngine.Init(MatrixPeriod))
      return(INIT_PARAMETERS_INCORRECT);

   return(INIT_SUCCEEDED);
  }

// --- 4. Executar a lógica principal em OnTick() ---
void OnTick()
  {
   // Preparar matrizes para armazenar os dados mais recentes dos preços de mercado
   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;

   // As matrizes devem ser configuradas como séries temporais (índice 0 = barra mais recente)
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);

   // Calcular a matriz de saída para a barra fechada mais recentemente (Índice 1)
   double current_matrix_strength = MatrixEngine.Calculate(1, high, low, close);

   // --- A. Módulo de Aprendizado de Máquina / Extração de Características ---
   // Insira 'current_matrix_strength' na sua rede neural
   // ou o vetor de características de IA como variável de entrada.

   // --- B. Módulo de Decisão de Negociação (Filtragem de Sinais) ---
   if(current_matrix_strength > EntryThreshold)
     {
      // A validação do momentum foi aprovada.
      // A tendência do mercado é considerada suficientemente forte.

      // -> Execute aqui ordens de COMPRA ou VENDA de acordo com
      //    à estratégia direcional do seu EA.

      // -> Como alternativa, use esse valor para dinamicamente
      //    ajustar o espaçamento da Smart Grid ou outros parâmetros adaptativos.
     }
  }

Método 2: Chamada via iCustom()

Se você lançar o arquivo .mq5 do indicador KCI Volatility Distance separadamente e quiser que o EA o leia por meio do buffer padrão de indicadores.

Trecho de código

// --- 1. Declarar o identificador do indicador no escopo global ---
int MatrixHandle;

// Parâmetros de entrada do EA
input int MatrixPeriod = 14;

// --- 2. Criar o identificador do indicador em OnInit() ---
int OnInit()
  {
   // Certifique-se de que o nome do arquivo do indicador corresponda exatamente
   // o arquivo localizado na pasta Indicadores.
   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. Ler os dados do buffer do indicador em OnTick() ---
void OnTick()
  {
   double MatrixBuffer[];
   ArraySetAsSeries(MatrixBuffer, true);

   // Recuperar os dois valores mais recentes do Buffer 0 (linha KCI-VD)
   if(CopyBuffer(MatrixHandle, 0, 0, 2, MatrixBuffer) <= 0)
     {
      Print("Failed to copy matrix buffer data.");
      return;
     }

   // Valor da matriz da vela fechada mais recentemente
   double current_matrix_strength = MatrixBuffer[1];

   // Valor da matriz da vela que está se formando no momento (em tempo real)
   double previous_matrix_strength = MatrixBuffer[0];

   // --- Lógica de decisão de negociação ---
   if(current_matrix_strength > previous_matrix_strength)
     {
      // O impulso está se ampliando.
      // -> Use isso como uma confirmação adicional para
      //    aumentar a distância do Take Profit.
      //
      // -> Como alternativa, use-o para acionar um adaptativo
      //    Ajuste do trailing stop.
     }
  }

Devido à arquitetura altamente adaptável e com baixo consumo de CPU do KCI Volatility Distance, seu potencial vai além dos indicadores visuais tradicionais. A flexibilidade de seu código baseado em Programação Orientada a Objetos (OOP) permite que ele atue como mecanismo para uma variedade de cenários algorítmicos avançados.

1. Sistema de defesa contra stop-hunting (SL e TP dinâmicos)

Movimentos repentinos de preço costumam ser armadilhas de liquidez (liquidity grab ou stop-hunt) em vez de tendências reais. A Distância de Volatilidade KCI é capaz de detectar essas anomalias.

• Lógica: Se houver um pico acentuado no preço, mas os valores da Matriz mostrarem um baixo nível de eficiência (direção), o EA detectará isso como um potencial stop-hunting.
• Implementação: Em vez de executar o Cut Loss ou definir um SL estático, o EA ampliará automaticamente a proteção do SL (SL dinâmico) até que a volatilidade diminua e, em seguida, buscará um ponto de recuperação mais ideal.

// Exemplo: Detecção de anomalias de volatilidade (filtro anti-stop-hunt)
double matrix_value = MatrixEngine.Calculate(1, high, low, close);

// O ATR serve como referência de volatilidade de base
double atr_baseline = iATR(_Symbol, _Period, 14);

// Detectar uma expansão anômala do mercado em relação à faixa de volatilidade esperada
if(matrix_value > (atr_baseline * 2.5))
  {
   Print("Warning: Volatility anomaly detected. Quantum SL Defense activated.");

   // Medidas de proteção:
   // - Impedir a abertura de novas posições.
   // - Ampliar dinamicamente o Stop Loss das posições existentes
   //   para reduzir a probabilidade de ocorrência de eventos de “stop-hunt”.
   ModifySLToSafeZone(matrix_value);
  }

2. Grade Inteligente Adaptativa e Algoritmo de Média

Um dos pontos fracos do sistema de grade padrão é seu espaçamento rígido (passos), o que é especialmente perigoso quando há uma forte tendência unidirecional.

• Lógica: Converte o espaçamento da Grid de valores estáticos (pontos) para coeficientes dinâmicos multiplicados pelo resultado de saída da Distância de Volatilidade do KCI.
• Implementação: Quando o mercado está lateral (a Matriz se expande), a distância entre as linhas da grade também aumenta. Isso evita que o EA abra posições em excesso em uma única área de consolidação, tornando-o muito seguro para suportar drawdowns em ativos com movimentos amplos, como XAUUSD, BTC ou o US30.

// Exemplo: Cálculo da distância na grade adaptativa
input double GridMultiplier = 1.5;

// Obter a medição mais recente da matriz direcional
double current_matrix = MatrixEngine.Calculate(0, high, low, close);

// Calcular o espaçamento da malha adaptativa usando o valor da matriz
// como uma representação dinâmica das condições atuais do mercado
double dynamic_grid_step = current_matrix * GridMultiplier;

// Abrir uma nova posição na grade somente após o mercado ter se movimentado
// além do limite de espaçamento calculado dinamicamente
if(MathAbs(CurrentPrice - LastOrderPrice) >= dynamic_grid_step)
  {
   // Executar a próxima ordem de Grid / Média
   ExecuteGridOrder();
  }

3. Normalização de características para aprendizado de máquina (ML)

Módulos: Os modelos de redes neurais exigem dados de entrada normalizados para reconhecer padrões com precisão, sem serem distorcidos por diferenças de dígitos nos preços entre corretoras ou classes de ativos (por exemplo, a diferença acentuada entre os preços do petróleo WTI e pares de moedas menos negociados).

• Lógica: Na fórmula da Distância de Volatilidade KCI, há um cálculo do Índice de Eficiência (ER) que produz naturalmente uma razão de escala de 0 a 1.
• Implementação: É possível modificar ligeiramente a classe OOP para retornar valores puros de ER. Essa matriz de valores é extraída para uma matriz como um conjunto de dados de treinamento muito limpo e livre de ruídos para o Pattern Learner.

//+------------------------------------------------------------------+
//|                                                        KCIVD.mqh |
//|                                   Direitos autorais 2026, KCI Developer |
//|                         https://www.mql5.com/pt/users/ritzfalih |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, KCI Developer"
#property link      "https://www.mql5.com/pt/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[]);
  };

//+------------------------------------------------------------------+
//| Construtor                                                      |
//+------------------------------------------------------------------+
CKCIVolatilityDistance::CKCIVolatilityDistance(void)
  {
   m_kinetic_period = 14;
   m_point          = _Point;
  }

//+------------------------------------------------------------------+
//| Destrutor                                                       |
//+------------------------------------------------------------------+
CKCIVolatilityDistance::~CKCIVolatilityDistance(void)
  {
  }

//+------------------------------------------------------------------+
//| Inicialização                                                   |
//+------------------------------------------------------------------+
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; // Mecanismo de segurança
   return(true);
     }

//+------------------------------------------------------------------+
//| Mecanismo central de cálculo (otimizado para CPU e velocidade)              |
//| Observação: as matrizes devem ser definidas como séries (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. Janela de loop otimizada sem funções aninhadas ---
   for(int j = 0; j < m_kinetic_period; j++)
     {
      int curr_idx = index + j;
      
      // Otimização da velocidade da comparação do True Range (evitando MathMax em camadas)
      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);

      // Comprimento do percurso do movimento do preço de fechamento (Índice de Eficiência)
      if(j < m_kinetic_period - 1)
        {
         path_length += MathAbs(close[curr_idx] - close[curr_idx + 1]);
        }
     }

   // --- 2. Cálculo da eficiência da razão ---
   double net_distance = MathAbs(close[index] - close[index + m_kinetic_period - 1]);
   
   if(path_length < net_distance) path_length = net_distance; // Limites lógicos
   if(path_length == 0.0)         path_length = m_point;      // Evitar divisão por zero
   
   double efficiency_ratio = net_distance / path_length;

   // --- 3. Cálculo do desvio padrão do 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; // Correção de precisão de ponto flutuante
   
   double std_TR = MathSqrt(variance);

   // --- 4. Resultado final do KCI VD ---
   return(std_TR * (2.0 - efficiency_ratio));
  }

Arquivo de indicador visual (KCI_Volatility_Distance.mq5) --- Outras opções ---

Salve este código na pasta MQL5\Indicators\. Este indicador agora está bem organizado, pois chama a estrutura OOP do arquivo .mqh acima.

Trecho de código

//+------------------------------------------------------------------+
//|                                      KCI Volatility Distance.mq5 |
//|                                   Direitos autorais 2026, KCI Developer |
//|                         https://www.mql5.com/pt/users/ritzfalih |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2026, KCI Developer"
#property link        "https://www.mql5.com/pt/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

// Incluir o Mesin Utama KCIVD
#include <KCIVD.mqh>

// --- Entrada ---
input group "=== KCI Volatility Settings ==="
input int KineticPeriod = 14;   // Período de cálculo (≥2)

// --- Buffer ---
double KVR_Buffer[];

// Instância de objeto global
CKCIVolatilityDistance kci_engine;

//+------------------------------------------------------------------+
//| Função de inicialização do indicador personalizado                         |
//+------------------------------------------------------------------+
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);
  }

//+------------------------------------------------------------------+
//| Função de iteração do indicador personalizado                              |
//+------------------------------------------------------------------+
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);

   // Definir o array padrão como uma série
   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);

   // Executar a máquina de cálculo por meio de um objeto OOP
   for(int i = limit; i >= 0 && !IsStopped(); i--)
     {
      KVR_Buffer[i] = kci_engine.Calculate(i, high, low, close);
     }

   return(rates_total);
  }

Guia de integração multifuncional (como usar em EA/ML)

Com a estrutura da classe CKCIVolatilityDistance, você pode utilizá-la diretamente em qualquer Expert Advisor para obter o máximo desempenho. Aqui está um exemplo de sua implementação lógica:

Integração no módulo de aprendizado de máquina (extração de características / validação de sinais)

Se você tiver uma rede neural ou um módulo de aprendizado de padrões que exija a normalização da volatilidade como característica de entrada, é possível extrair o valor KCI VD de forma pura:

Trecho de código

#include <KCIVD.mqh>

CKCIVolatilityDistance KCI_ML;

int OnInit()
  {
   // Inicializar o mecanismo de distância de volatilidade KCI
   // com o período de cálculo desejado.
   KCI_ML.Init(14);

   return(INIT_SUCCEEDED);
  }

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

   // Copiar uma quantidade suficiente de dados históricos de preços
   // (por exemplo, as 50 barras mais recentes) em matrizes locais.
   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);

   // Calcular o valor da Distância de Volatilidade do KCI para
   // a barra atual (índice 0) ou a última barra fechada (índice 1).
   double kci_current_volatility = KCI_ML.Calculate(0, high, low, close);

   // Insira 'kci_current_volatility' na rede neural
   // vetor de características para validação ou previsão de sinais.
  }

4. Scanner de múltiplos símbolos (indicador de painel)

Como o KCIDirectionalMatrix não depende do iCustom e libera a memória local rapidamente, ele é perfeito como mecanismo de busca de sinais em um painel com vários símbolos.

• Lógica: instale um indicador de painel em um gráfico, mas execute o loop de cálculo da matriz para 20 a 30 símbolos diferentes simultaneamente.
• Implementação: O indicador fará a varredura de todo o Market Watch (Principais, Cruzados, Metais, Índices) para identificar ativos cujos valores da Matriz estejam se contraindo (preparando-se para um rompimento) ou apresentando forte momentum de tendência. Isso evitará que o VPS do Windows Server fique lento ou sobrecarregue a CPU.

// Exemplo: Mecanismo de varredura do mercado de múltiplos ativos
string symbols[] = {"EURUSD", "GBPUSD", "XAUUSD", "BTCUSD", "US30"};

for(int s = 0; s < ArraySize(symbols); s++)
  {
   // Carregar os dados históricos de mercado necessários
   // para o instrumento de negociação atual.
   // ...

   // Avaliar a força direcional
   // da vela concluída mais recentemente.
   double strength = MatrixEngine.Calculate(1, h, l, c);

   // Gerar um sinal de negociação somente quando o
   // a intensidade direcional excede o limite configurado.
   if(strength > Threshold)
     {
      // Atualizar o painel com os dados detectados
      // Oportunidade de COMPRA/VENDA para o instrumento atual.
      DrawDashboardSignal(symbols[s], strength);
     }
  }

Este é o código do KCI Volatility Distance; no mínimo, esse código pode ser usado para diversos fins. Você pode desenvolvê-lo ainda mais com indicadores padrão do MT5 e indicadores personalizados do MT5 para alcançar uma precisão ainda maior e uma análise mais exata.