KCI Volatility Distance - indicador para MetaTrader 5

Imagen 1

Imagen 3

Configuración sencilla de los parámetros

Imagen 2

Guía de integración de KCI Volatility Distance en un Asesor Experto (EA)

Existen dos métodos principales para integrar este algoritmo en un EA. El primer método (OOP integrado) es muy recomendable para obtener la máxima eficiencia de la CPU y la recopilación de conjuntos de datos para el aprendizaje automático. El segundo método (invocación iCustom) es adecuado para pruebas rápidas de prototipos.

Método 1: Uso directo a través de la clase OOP integrada (ultraligera)

• Este método integra el motor directamente en el EA sin llamar a indicadores externos. El código se coloca a nivel global, se inicializa en OnInit y se ejecuta en OnTick.

// --- 1. Coloca la clase OOP al principio del archivo EA o inclúyela mediante #include ---
class CKCIDirectionalMatrix
  {
   // (Inserta aquí la implementación completa de la clase CKCIDirectionalMatrix)
   // ...
  };

// --- 2. Declarar la instancia del objeto global ---
CKCIDirectionalMatrix MatrixEngine;

// Parámetros de entrada de EA
input int MatrixPeriod = 14;
input double EntryThreshold = 0.0050; // Umbral de intensidad del impulso

// --- 3. Inicializar el motor en OnInit() ---
int OnInit()
  {
   if(!MatrixEngine.Init(MatrixPeriod))
      return(INIT_PARAMETERS_INCORRECT);

   return(INIT_SUCCEEDED);
  }

// --- 4. Ejecutar la lógica principal en OnTick() ---
void OnTick()
  {
   // Preparar matrices para almacenar los datos más recientes sobre los precios 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;

   // Las matrices deben configurarse como series temporales (índice 0 = barra más reciente)
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);

   // Calcular la matriz de salida correspondiente a la barra cerrada más recientemente (índice 1)
   double current_matrix_strength = MatrixEngine.Calculate(1, high, low, close);

   // --- A. Módulo de aprendizaje automático / extracción de características ---
   // Introduce «current_matrix_strength» en tu red neuronal
   // o un vector de características de IA como variable de entrada.

   // --- B. Módulo de decisión de negociación (filtrado de señales) ---
   if(current_matrix_strength > EntryThreshold)
     {
      // Se ha superado la validación del momento.
      // Se considera que la tendencia del mercado es lo suficientemente sólida.

      // -> Ejecuta aquí las órdenes de COMPRA o VENTA según
      //    a la estrategia direccional de tu EA.

      // -> Como alternativa, utiliza este valor para, de forma dinámica,
      //    Ajustar el espaciado de Smart Grid u otros parámetros adaptativos.
     }
  }

Método 2: Llamada a través de iCustom()

Si publica por separado el archivo .mq5 del indicador KCI Volatility Distance y desea que el EA lo lea a través del búfer de indicadores estándar.

Fragmento de código

// --- 1. Declarar el identificador del indicador en el ámbito global ---
int MatrixHandle;

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

// --- 2. Crear el identificador del indicador en OnInit() ---
int OnInit()
  {
   // Asegúrate de que el nombre del archivo indicador coincida exactamente
   // el archivo que se encuentra en la carpeta «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. Leer los datos del búfer de indicadores en OnTick() ---
void OnTick()
  {
   double MatrixBuffer[];
   ArraySetAsSeries(MatrixBuffer, true);

   // Recuperar los dos valores más recientes del búfer 0 (línea KCI-VD)
   if(CopyBuffer(MatrixHandle, 0, 0, 2, MatrixBuffer) <= 0)
     {
      Print("Failed to copy matrix buffer data.");
      return;
     }

   // Valor de la matriz correspondiente a la vela cerrada más reciente
   double current_matrix_strength = MatrixBuffer[1];

   // Valor de la matriz correspondiente a la vela que se está formando actualmente (en tiempo real)
   double previous_matrix_strength = MatrixBuffer[0];

   // --- Lógica de decisión de negociación ---
   if(current_matrix_strength > previous_matrix_strength)
     {
      // El impulso va en aumento.
      // -> Utiliza esto como confirmación adicional para
      //    Aumentar la distancia del «Take Profit».
      //
      // -> Como alternativa, utilízalo para activar un sistema adaptativo
      //    Ajuste del trailing stop.
     }
  }

Dada la arquitectura altamente adaptable y de bajo consumo de CPU del KCI Volatility Distance, su potencial va más allá de los indicadores visuales tradicionales. La flexibilidad de su código basado en la programación orientada a objetos (POO) le permite servir como motor para una variedad de escenarios algorítmicos avanzados.

1. Sistema de defensa contra el «stop-hunting» (SL y TP dinámicos)

Los movimientos bruscos de los precios suelen ser trampas de liquidez («liquidity grab» o «stop-hunt») más que tendencias reales. La distancia de volatilidad KCI puede detectar estas anomalías.

• Lógica: si se produce un repunte brusco del precio, pero los valores de la matriz muestran un bajo nivel de eficiencia (dirección), el EA lo detectará como un posible «stop-hunting».
• Implementación: En lugar de ejecutar un «Cut Loss» o colocar un SL estático, el EA ampliará automáticamente la protección del SL (SL dinámico) hasta que la volatilidad remita, para luego buscar un punto de recuperación más óptimo.

// Ejemplo: Detección de anomalías de volatilidad (filtro anti-stop-hunt)
double matrix_value = MatrixEngine.Calculate(1, high, low, close);

// El ATR sirve como índice de referencia de la volatilidad
double atr_baseline = iATR(_Symbol, _Period, 14);

// Detectar una expansión anómala del mercado en relación con el rango de volatilidad esperado
if(matrix_value > (atr_baseline * 2.5))
  {
   Print("Warning: Volatility anomaly detected. Quantum SL Defense activated.");

   // Medidas de protección:
   // - Evitar la apertura de nuevas posiciones.
   // - Ampliar dinámicamente el Stop Loss de las posiciones existentes
   //   para reducir la probabilidad de que se produzcan eventos de «stop-hunt».
   ModifySLToSafeZone(matrix_value);
  }

2. Red inteligente adaptativa y algoritmo de promediado

Uno de los puntos débiles del sistema de rejilla estándar es su espaciado rígido (pasos), lo cual resulta especialmente peligroso cuando la tendencia unidireccional es fuerte.

• Lógica: Convierte el espaciado de la rejilla de valores estáticos (puntos) a coeficientes dinámicos multiplicados por el resultado de salida de la «Distancia de volatilidad KCI».
• Implementación: Cuando el mercado se mueve lateralmente (la matriz se expande), la distancia entre las líneas de la rejilla también se amplía. Esto evita que el EA abra demasiadas posiciones en una misma zona de consolidación, lo que lo hace muy seguro para soportar las caídas en activos con amplios movimientos como el XAUUSD, el BTC o el US30.

// Ejemplo: Cálculo de la distancia en una cuadrícula adaptativa
input double GridMultiplier = 1.5;

// Obtener la última medición de la matriz direccional
double current_matrix = MatrixEngine.Calculate(0, high, low, close);

// Calcular el espaciado de la malla adaptativa utilizando el valor de la matriz
// como una representación dinámica de las condiciones actuales del mercado
double dynamic_grid_step = current_matrix * GridMultiplier;

// Abrir una nueva posición en la cuadrícula solo después de que el mercado haya variado
// más allá del umbral de espaciado calculado dinámicamente
if(MathAbs(CurrentPrice - LastOrderPrice) >= dynamic_grid_step)
  {
   // Ejecutar la siguiente orden de «Grid» / «Averaging»
   ExecuteGridOrder();
  }

3. Normalización de características para el aprendizaje automático (ML)

Módulos: Los modelos de redes neuronales requieren datos de entrada normalizados para reconocer patrones con precisión, sin que se vean distorsionados por las diferencias en los dígitos de los precios entre brókers o clases de activos (por ejemplo, la marcada diferencia entre los precios del petróleo WTI y los pares de divisas menores).

• Lógica: Dentro de la fórmula de la distancia de volatilidad KCI, hay un cálculo del índice de eficiencia (ER) que produce de forma natural una relación de escala de 0 a 1.
• Implementación: Se puede modificar ligeramente la clase OOP para que devuelva valores de ER puros. Esta matriz de valores se extrae a un array como un conjunto de datos de entrenamiento muy limpio y sin ruido para el Pattern Learner.

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

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

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

//+------------------------------------------------------------------+
//| Inicialización                                                   |
//+------------------------------------------------------------------+
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; // Medida de seguridad alternativa
   return(true);
     }

//+------------------------------------------------------------------+
//| Motor de cálculo principal (optimizado para CPU y velocidad)              |
//| Nota: Las matrices deben configurarse como series (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. Ventana de bucle optimizada sin funciones anidadas ---
   for(int j = 0; j < m_kinetic_period; j++)
     {
      int curr_idx = index + j;
      
      // Optimización de la velocidad de comparación del «True Range» (evitando el uso de MathMax en varios niveles)
      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);

      // Longitud del recorrido del cierre (índice de eficiencia)
      if(j < m_kinetic_period - 1)
        {
         path_length += MathAbs(close[curr_idx] - close[curr_idx + 1]);
        }
     }

   // --- 2. Cálculo de la eficiencia de la relación ---
   double net_distance = MathAbs(close[index] - close[index + m_kinetic_period - 1]);
   
   if(path_length < net_distance) path_length = net_distance; // Límites lógicos
   if(path_length == 0.0)         path_length = m_point;      // Evitar la división por cero
   
   double efficiency_ratio = net_distance / path_length;

   // --- 3. Cálculo de la desviación estándar del 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; // Corrección de la precisión de los números de coma flotante
   
   double std_TR = MathSqrt(variance);

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

Archivo de indicador visual (KCI_Volatility_Distance.mq5) --- Otras opciones ---

Guarda este código en la carpeta MQL5\Indicators\. Este indicador tiene ahora un código muy limpio, ya que invoca la estructura OOP del archivo .mqh anterior.

Fragmento de código

//+------------------------------------------------------------------+
//|                                      KCI Volatility Distance.mq5 |
//|                                   Copyright 2026, KCI Developer |
//|                         https://www.mql5.com/es/users/ritzfalih |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2026, KCI Developer"
#property link        "https://www.mql5.com/es/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 Mesin Utama KCIVD
#include <KCIVD.mqh>

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

// --- Búfer ---
double KVR_Buffer[];

// Instancia de objeto global
CKCIVolatilityDistance kci_engine;

//+------------------------------------------------------------------+
//| Función de inicialización de indicadores personalizados                         |
//+------------------------------------------------------------------+
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);
  }

//+------------------------------------------------------------------+
//| Función de iteración del 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);

   // Configurar el array predeterminado como serie
   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);

   // Ejecutar la máquina de cálculo mediante un objeto de programación orientada a objetos (OOP)
   for(int i = limit; i >= 0 && !IsStopped(); i--)
     {
      KVR_Buffer[i] = kci_engine.Calculate(i, high, low, close);
     }

   return(rates_total);
  }

Guía de integración multifuncional (cómo utilizarlo en EA/ML)

Con la estructura de la clase CKCIVolatilityDistance, puedes utilizarla directamente en cualquier asesor experto para obtener el máximo rendimiento. A continuación se muestra un ejemplo de su implementación lógica:

Integración en el módulo de aprendizaje automático (extracción de características / validación de señales)

Si dispone de una red neuronal o de un módulo de aprendizaje de patrones que requiera la normalización de la volatilidad como característica de entrada, puede extraer el valor KCI VD de forma pura:

Fragmento de código

#include <KCIVD.mqh>

CKCIVolatilityDistance KCI_ML;

int OnInit()
  {
   // Inicializar el motor de distancia de volatilidad de KCI
   // con el periodo de cálculo deseado.
   KCI_ML.Init(14);

   return(INIT_SUCCEEDED);
  }

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

   // Copiar una cantidad suficiente de datos históricos de precios
   // (por ejemplo, las 50 barras más recientes) en matrices locales.
   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 el valor de la «distancia de volatilidad» del KCI para
   // la barra actual (índice 0) o la última barra cerrada (índice 1).
   double kci_current_volatility = KCI_ML.Calculate(0, high, low, close);

   // Introducir «kci_current_volatility» en la red neuronal
   // vector de características para la validación o predicción de señales.
  }

4. Escáner multisímbolo (indicador de panel de control)

Dado que KCIDirectionalMatrix no depende de iCustom y libera rápidamente la memoria local, resulta perfecto como motor de búsqueda de señales en un panel de control multisímbolos.

• Lógica: Instala un indicador de panel en un gráfico, pero ejecuta el bucle de cálculo de la matriz para 20-30 símbolos diferentes simultáneamente.
• Implementación: El indicador analizará todo el Market Watch (divisas principales, cruces, metales e índices) para identificar activos cuyos valores de la matriz se estén contrayendo (preparándose para una ruptura) o que estén experimentando un fuerte impulso de tendencia. Esto evitará que el VPS de Windows Server sufra retrasos o sobrecargue la CPU.

// Ejemplo: Motor de análisis de mercados de múltiples activos
string symbols[] = {"EURUSD", "GBPUSD", "XAUUSD", "BTCUSD", "US30"};

for(int s = 0; s < ArraySize(symbols); s++)
  {
   // Cargar los datos históricos de mercado necesarios
   // para el instrumento de negociación actual.
   // ...

   // Calcular la intensidad direccional
   // de la vela que se ha cerrado más recientemente.
   double strength = MatrixEngine.Calculate(1, h, l, c);

   // Generar una señal de negociación solo cuando el
   // La intensidad direccional supera el umbral configurado.
   if(strength > Threshold)
     {
      // Actualizar el panel de control con los datos detectados
      // Oportunidad de COMPRA/VENTA para el instrumento actual.
      DrawDashboardSignal(symbols[s], strength);
     }
  }

Este es el código de KCI Volatility Distance; como mínimo, este código se puede utilizar para diversos fines. Puedes seguir desarrollándolo con indicadores estándar de MT5 e indicadores personalizados de MT5 para lograr una precisión aún mayor y un análisis más exacto.