KCI Directional Matrix - indicador para MetaTrader 5

• ESENARIO B: La ruptura bajista (VENTA)
• Comprueba la línea dorada: debe cruzar al ALZA y superar el nivel 20. (Sí, sube incluso en tendencias bajistas, ¡porque la energía bajista está aumentando!)
  
• Comprueba las líneas discontinuas: la línea roja (-KDI) debe cruzar POR ENCIMA de la línea azul (+KDI).
  
• Ejecución: Abre una posición de VENTA.
  

• ESENARIO C: La recogida de beneficios (SALIDA)
• Comprueba la línea dorada: ya estás en una operación y la línea dorada toca o cruza el nivel 80.
  
• Ejecución: Mueve tu Stop Loss al punto de equilibrio, activa un Trailing Stop ajustado o cierra la posición para asegurar las ganancias.
  

• Lógica de entrada de compra (alcista):
• KDI_Plus cruza por encima de KDI_Minus (cruce).
• Filtro: KCI_Main debe estar por encima del nivel 20 (lo que confirma que el mercado ha salido de la zona de compresión o de movimiento lateral).

• Lógica de entrada de venta (bajista):
• El KDI Minus cruza al alza por encima del KDI Plus (cruce).
• Filtro: el KCI_Main debe estar por encima del nivel 20.

• Lógica de salida / Take Profit / Trailing:
• Si el KCI_Main alcanza el nivel 80 (tendencia extrema), el EA debe activar un trailing stop ajustado o realizar un take profit parcial, ya que la energía de la tendencia se encuentra en su máximo y existe potencial de corrección.

//+------------------------------------------------------------------+
//|                                                 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()
  {
   // Crear el identificador del indicador personalizado.
   // Asegúrate de que «KCI-Directional_X.ex5» se encuentre en
   // en el directorio 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 los búferes de indicadores como series temporales
   // (Índice 0 = barra actual).
   ArraySetAsSeries(KCI_Main, true);
   ArraySetAsSeries(KDI_Plus, true);
   ArraySetAsSeries(KDI_Minus, true);

   return(INIT_SUCCEEDED);
  }

void OnTick()
  {
   // Obtener los últimos valores de los indicadores
   // (la barra actual y la barra cerrada más recientemente).
   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 negociación de KCI-DX
   // Todas las decisiones de negociación se basan en la última vela completada
   // (Índice 1) para evitar las señales de la vela que aún se está formando.
   // ------------------------------------------------------------

   // Detectar si el mercado se encuentra en una situación de tendencia.
   bool isTrending = KCI_Main[1] > 20.0;

   // Detectar un cruce direccional alcista.
   bool buySignal  = (KDI_Plus[1] > KDI_Minus[1]) &&
                     (KDI_Plus[2] <= KDI_Minus[2]);

   // Detectar un cruce direccional bajista.
   bool sellSignal = (KDI_Minus[1] > KDI_Plus[1]) &&
                     (KDI_Minus[2] <= KDI_Plus[2]);

   // Detectar una expansión extrema de la tendencia.
   bool isExtreme  = KCI_Main[1] >= 80.0;

   // Ejemplo de lógica de ejecución de operaciones.
   if(isTrending && buySignal)
     {
      Print("KCI-DX BUY signal detected.");

      // Realiza la ejecución de tu orden de COMPRA
      // (OrderSend o CTrade::Buy) aquí.
     }
   else if(isTrending && sellSignal)
     {
      Print("KCI-DX SELL signal detected.");

      // Realiza la ejecución de tu orden de VENTA
      // (OrderSend o CTrade::Sell) aquí.
     }

   // Gestión opcional de las operaciones en caso de tendencias marcadas del mercado.
   if(isExtreme)
     {
      Print("Extreme trend detected. Consider activating a trailing stop or managing existing positions.");
     }
  }

Ejemplo de código de EA con cálculos integrados (integrados directamente) (integrados en el motor KCI-N Matrix del EA)

Este método incorpora su algoritmo matemático directamente en el EA sin necesidad de archivos de indicadores externos. Dado que el cálculo requiere datos históricos para la puntuación Z, utilizamos una función especial dentro del EA para procesar la matriz de precios.

Fragmento 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;

// Estructura utilizada para devolver los tres valores de KCI-DX
// a partir de un único cálculo.
struct KCI_Result
  {
   double main;
   double plus;
   double minus;
  };

// Calcular la puntuación Z interna utilizada para
// normalización 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 los valores de KCI-DX para un valor especificado
// barra histórica (shift).
KCI_Result CalculateKCI(int shift)
  {
   KCI_Result res;
   res.main = 0.0;
   res.plus = 0.0;
   res.minus = 0.0;

   // Obtener un número suficiente de precios de cierre históricos
   // tanto para el período de referencia como para la ventana de la puntuación Z.
   int required_bars = InpZScorePeriod + InpBasePeriod;

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

   if(CopyClose(_Symbol, _Period, shift, required_bars, close) < required_bars)
      return res;   // Datos 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:
   // Extracción direccional 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:
   // Normalización 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 los valores del KCI-DX para el
   // las dos velas más recientes que se han cerrado.
   KCI_Result kci_current = CalculateKCI(1);
   KCI_Result kci_prev    = CalculateKCI(2);

   // ------------------------------------------------------------
   // Ejemplo de lógica de negociación
   // Detectar un cruce direccional alcista.
   // ------------------------------------------------------------
   bool buySignal =
      (kci_current.plus > kci_current.minus) &&
      (kci_prev.plus <= kci_prev.minus);

   // Ejecutar la lógica de negociación solo cuando el mercado
   // se encuentra en una situación de tendencia válida.
   if(kci_current.main > 20.0 && buySignal)
     {
      Print("Embedded KCI-DX detected a BUY signal.");

      // Realiza la ejecución de tu orden de COMPRA
      // (OrderSend o CTrade::Buy) aquí.
     }
  }

Recomendaciones para obtener los mejores resultados

Antes de compilar y operar, ten en cuenta estas prácticas recomendadas para sacar el máximo partido a la Matriz KCI-Directional:

• Flexibilidad de activos: Los parámetros predeterminados (BasePeriod=9, ZScorePeriod=30) son muy sensibles y funcionan excepcionalmente bien con los principales pares de divisas. Sin embargo, si lo aplicas a instrumentos altamente volátiles como el oro (XAUUSD), las criptomonedas (BTC/ETH) o los índices, considera aumentar ligeramente el ZScorePeriod (por ejemplo, a 40 o 50) para filtrar el ruido excesivo.

• Optimización algorítmica: Para los desarrolladores de EA que crean sistemas complejos o con múltiples símbolos, se recomienda encarecidamente utilizar el método de cálculo integrado que se ha indicado anteriormente. Mantiene un consumo de CPU increíblemente bajo y garantiza que tu Asesor Experto siga siendo totalmente autónomo sin necesidad de llamar a indicadores externos.

• Combinación para la confluencia: KCI-DX es un motor específico de cinemática y volatilidad. Aunque proporciona un excelente sesgo direccional por sí solo, resulta verdaderamente formidable cuando se combina con tus filtros estructurales favoritos (como las zonas de soporte/resistencia) o con detectores de anomalías de volumen para validar la entrada final.

Declaración final

Nota del autor / Conclusión: Gracias por explorar la Matriz Direccional KCI. Este código se ha diseñado con el objetivo específico de proporcionar a la comunidad MQL5 una herramienta analítica ligera, matemáticamente rigurosa y altamente adaptable. Tanto si eres un operador manual que busca puntos precisos de agotamiento del impulso, como si eres un desarrollador que integra datos legibles por máquina en un Asesor Experto, espero que este indicador sirva como una base sólida para tus proyectos.

Si este código te resulta útil para tus sistemas de trading, no dudes en dejar una reseña, compartir tus modificaciones creativas o plantear una pregunta en la sección de debate que aparece a continuación. ¡Sigamos ampliando juntos los límites del trading algorítmico!

Feliz programación y opera con seguridad, — Ritz