KCI Directional Matrix - indicador para MetaTrader 5

• CENÁRIO B: A quebra de baixa (VENDA)
• Verifique a linha dourada: ela deve estar cruzando para CIMA e rompendo acima do nível 20. (Sim, ela sobe mesmo em tendências de baixa, pois a energia de queda está aumentando!)
  
• Verifique as linhas tracejadas: a linha vermelha (-KDI) deve cruzar ACIMA da linha azul (+KDI).
  
• Execução: Abra uma posição de VENDA.
  

• CENÁRIO C: A realização de lucro (SAÍDA)
• Verifique a Linha Dourada: você já está em uma operação, e a Linha Dourada toca ou cruza o nível 80.
  
• Execução: Mova seu Stop Loss para o ponto de equilíbrio, ative um Trailing Stop apertado ou feche a posição para garantir os lucros.
  

• Lógica de entrada de compra (alta):
• O KDI_Plus cruza acima do KDI_Minus (crossover).
• Filtro: o KCI_Main deve estar acima do nível 20 (confirmando que o mercado está fora da zona de compressão/lateral).

• Lógica de entrada de venda (baixa):
• O KDI Minus cruza para cima do KDI Plus (cruzamento).
• Filtro: o KCI_Main deve estar acima do nível 20.

• Lógica de saída / Take Profit / Trailing:
• Se o KCI_Main atingir o nível 80 (Tendência Extrema), o EA deve ativar um Trailing Stop apertado ou realizar um Take Profit parcial, pois a energia da tendência está no máximo e há potencial para correção.

//+------------------------------------------------------------------+
//|                                                 EA_KCI_iCustom.mq5 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Ritz"
#property version   "1.00"

int kci_handle;
double KCI_Main[], KDI_Plus[], KDI_Minus[];

int OnInit()
  {
   // Criar o identificador do indicador personalizado.
   // Verifique se o arquivo “KCI-Directional_X.ex5” está localizado
   // no diretório MQL5/Indicators.
   kci_handle = iCustom(_Symbol, _Period, "KCI-Directional_X", 9, 30, 1.5);

   if(kci_handle == INVALID_HANDLE)
     {
      Print("Failed to load the KCI-DX indicator.");
      return(INIT_FAILED);
     }

   // Configurar os buffers dos indicadores como séries temporais
   // (Índice 0 = barra atual).
   ArraySetAsSeries(KCI_Main, true);
   ArraySetAsSeries(KDI_Plus, true);
   ArraySetAsSeries(KDI_Minus, true);

   return(INIT_SUCCEEDED);
  }

void OnTick()
  {
   // Recuperar os valores mais recentes dos indicadores
   // (a barra atual e a barra fechada mais recentemente).
   if(CopyBuffer(kci_handle, 0, 0, 2, KCI_Main) <= 0)
      return;

   if(CopyBuffer(kci_handle, 1, 0, 2, KDI_Plus) <= 0)
      return;

   if(CopyBuffer(kci_handle, 2, 0, 2, KDI_Minus) <= 0)
      return;

   // ------------------------------------------------------------
   // Lógica de negociação KCI-DX
   // Todas as decisões de negociação são baseadas na última vela fechada
   // (Índice 1) para evitar sinais da vela que ainda está se formando.
   // ------------------------------------------------------------

   // Detectar se o mercado está em uma condição de tendência.
   bool isTrending = KCI_Main[1] > 20.0;

   // Detectar um cruzamento direcional de alta.
   bool buySignal  = (KDI_Plus[1] > KDI_Minus[1]) &&
                     (KDI_Plus[2] <= KDI_Minus[2]);

   // Detectar um cruzamento direcional de baixa.
   bool sellSignal = (KDI_Minus[1] > KDI_Plus[1]) &&
                     (KDI_Minus[2] <= KDI_Plus[2]);

   // Detectar uma expansão extrema da tendência.
   bool isExtreme  = KCI_Main[1] >= 80.0;

   // Exemplo de lógica de execução de negociação.
   if(isTrending && buySignal)
     {
      Print("KCI-DX BUY signal detected.");

      // Execute sua ordem de COMPRA
      // (OrderSend ou CTrade::Buy) aqui.
     }
   else if(isTrending && sellSignal)
     {
      Print("KCI-DX SELL signal detected.");

      // Execute sua ordem de VENDA
      // (OrderSend ou CTrade::Sell) aqui.
     }

   // Gestão opcional de operações para tendências de mercado marcantes.
   if(isExtreme)
     {
      Print("Extreme trend detected. Consider activating a trailing stop or managing existing positions.");
     }
  }

Exemplo de código de EA com cálculos incorporados (incorporados diretamente) (incorporados no mecanismo KCI-N Matrix do EA)

Esse método incorpora seu algoritmo matemático diretamente no EA, sem a necessidade de arquivos de indicadores externos. Como o cálculo requer dados históricos para o Z-Score, usamos uma função especial dentro do EA para processar a matriz de preços.

Trecho de código:

//+------------------------------------------------------------------+
//|                                              EA_KCI_Embedded.mq5 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Ritz"
#property version   "1.00"

input int    InpBasePeriod   = 9;
input int    InpZScorePeriod = 30;
input double InpSensitivity  = 1.5;

// Estrutura usada para retornar os três valores do KCI-DX
// a partir de um único cálculo.
struct KCI_Result
  {
   double main;
   double plus;
   double minus;
  };

// Calcular o Z-Score interno utilizado para
// normalização dinâmica.
double EmbeddedZScore(double &data_array[], int period)
  {
   if(period < 2)
      return 0.0;

   double sum = 0.0;
   double sum_sq = 0.0;

   for(int i = 0; i < period; i++)
     {
      sum += data_array[i];
      sum_sq += data_array[i] * data_array[i];
     }

   double mean = sum / period;
   double variance = (sum_sq / period) - (mean * mean);

   if(variance <= 1 e-10)
      return 0.0;

   return (data_array[0] - mean) / MathSqrt(variance);
  }

// Calcular os valores do KCI-DX para um
// barra histórica (shift).
KCI_Result CalculateKCI(int shift)
  {
   KCI_Result res;
   res.main = 0.0;
   res.plus = 0.0;
   res.minus = 0.0;

   // Recuperar preços de fechamento históricos suficientes
   // tanto para o Período Base quanto para a janela do Z-Score.
   int required_bars = InpZScorePeriod + InpBasePeriod;

   double close[];
   ArraySetAsSeries(close, true);

   if(CopyClose(_Symbol, _Period, shift, required_bars, close) < required_bars)
      return res;   // Dados históricos insuficientes.

   double raw_plus[];
   double raw_minus[];
   double raw_trend[];

   ArrayResize(raw_plus, InpZScorePeriod);
   ArrayResize(raw_minus, InpZScorePeriod);
   ArrayResize(raw_trend, InpZScorePeriod);

   // ------------------------------------------------------------
   // Fase 1:
   // Extração direcional cinemática
   // ------------------------------------------------------------
   for(int i = 0; i < InpZScorePeriod; i++)
     {
      double path_len = 0.000001;
      double net_up = 0.0;
      double net_dn = 0.0;
      double mean_p = 0.0;

      for(int j = 0; j < InpBasePeriod; j++)
        {
         double diff = close[i + j] - close[i + j + 1];

         path_len += MathAbs(diff);

         if(diff > 0)
            net_up += diff;
         else
            net_dn -= diff;

         mean_p += close[i + j];
        }

      mean_p /= InpBasePeriod;

      double var_p = 0.0;

      for(int j = 0; j < InpBasePeriod; j++)
         var_p += MathPow(close[i + j] - mean_p, 2);

      double energy = MathSqrt(var_p / InpBasePeriod);

      raw_plus[i]  = (net_up / path_len) * energy;
      raw_minus[i] = (net_dn / path_len) * energy;
      raw_trend[i] = (MathAbs(net_up - net_dn) / path_len) * energy;
     }

   // ------------------------------------------------------------
   // Fase 2:
   // Normalização sigmoide dinâmica
   // ------------------------------------------------------------
   double z_plus  = EmbeddedZScore(raw_plus, InpZScorePeriod);
   double z_minus = EmbeddedZScore(raw_minus, InpZScorePeriod);
   double z_trend = EmbeddedZScore(raw_trend, InpZScorePeriod);

   res.plus  = 100.0 / (1.0 + MathExp(-InpSensitivity * z_plus));
   res.minus = 100.0 / (1.0 + MathExp(-InpSensitivity * z_minus));
   res.main  = 100.0 / (1.0 + MathExp(-InpSensitivity * z_trend));

   return res;
  }

void OnTick()
  {
   // Calcular os valores do KCI-DX para o
   // as duas velas fechadas mais recentes.
   KCI_Result kci_current = CalculateKCI(1);
   KCI_Result kci_prev    = CalculateKCI(2);

   // ------------------------------------------------------------
   // Exemplo de lógica de negociação
   // Detectar um cruzamento direcional de alta.
   // ------------------------------------------------------------
   bool buySignal =
      (kci_current.plus > kci_current.minus) &&
      (kci_prev.plus <= kci_prev.minus);

   // Executar a lógica de negociação somente quando o mercado
   // está em uma condição válida de tendência.
   if(kci_current.main > 20.0 && buySignal)
     {
      Print("Embedded KCI-DX detected a BUY signal.");

      // Execute sua ordem de COMPRA
      // (OrderSend ou CTrade::Buy) aqui.
     }
  }

Recomendações para obter os melhores resultados

Antes de compilar e operar, tenha em mente estas práticas recomendadas para aproveitar ao máximo a Matriz Direcional KCI:

• Flexibilidade de ativos: Os parâmetros padrão (BasePeriod=9, ZScorePeriod=30) são altamente responsivos e apresentam desempenho excepcional nos principais pares de moedas. No entanto, se você estiver aplicando isso a instrumentos altamente voláteis, como o ouro (XAUUSD), criptomoedas (BTC/ETH) ou índices, considere aumentar ligeiramente o ZScorePeriod (por exemplo, para 40 ou 50) para filtrar ruídos excessivos.

• Otimização algorítmica: Para desenvolvedores de EAs que criam sistemas complexos ou com múltiplos símbolos, é altamente recomendável utilizar o método de cálculo embutido fornecido acima. Ele mantém o uso da CPU incrivelmente baixo e garante que seu Expert Advisor permaneça totalmente autônomo, sem a necessidade de chamadas a indicadores externos.

• Combinação para Confluência: O KCI-DX é um mecanismo dedicado à cinemática e à volatilidade. Embora ofereça excelente tendência direcional por si só, ele se torna verdadeiramente formidável quando combinado com seus filtros estruturais favoritos (como zonas de suporte/resistência) ou detectores de anomalias de volume para validar a entrada final.

Declaração Final

Nota do autor / Conclusão: Obrigado por explorar a Matriz Direcional KCI. Esta base de código foi projetada com foco estrito em fornecer à comunidade MQL5 uma ferramenta analítica leve, matematicamente rigorosa e altamente adaptável. Seja você um trader manual em busca de pontos precisos de esgotamento do momentum ou um desenvolvedor integrando dados legíveis por máquina a um Expert Advisor, espero que este indicador sirva como uma base robusta para seus projetos.

Se você achar este código valioso para seus sistemas de negociação, sinta-se à vontade para deixar uma avaliação, compartilhar suas modificações criativas ou fazer uma pergunta na seção de discussão abaixo. Vamos continuar expandindo os limites da negociação algorítmica juntos!

Boa programação e negocie com segurança, — Ritz