KCI Standard: A Pure Kinematic Computing Engine for Market Singularity Detection - indicador para MetaTrader 5

Resumen

El Índice de Compresión Cinética (KCI) es un oscilador personalizado diseñado para detectar el agotamiento del mercado y los eventos de compresión localizados. Al calcular sus métricas cinemáticas internamente, en lugar de basarse en indicadores estándar externos, el KCI reduce la sobrecarga y simplifica la gestión de búferes para la integración con los Asesores Expertos (EA). Este artículo detalla los fundamentos matemáticos, la arquitectura del sistema, la asignación de búferes y las guías prácticas de integración para los desarrolladores que deseen implementar esta herramienta en MetaTrader 5.

Planteamiento del problema

Los objetivos principales de la arquitectura del KCI son:

1. Reducir la dependencia de los «handles»: calcular medias móviles y desviaciones de forma nativa dentro del bucle del indicador para minimizar el uso de «handles» externos.

2. Proporcionar métricas reproducibles: Ofrecer a los EA métricas matemáticas claras y transparentes (velocidad, desviación y dispersión).

3. Garantizar la seguridad asíncrona: crear búferes de señales que solo se validen en barras cerradas, protegiendo al EA del repintado intrabarral y de los retrasos asíncronos en los datos de ticks.

Teoría y fundamentos matemáticos

El KCI se basa en cuatro métricas fundamentales. Para garantizar una reproducibilidad total, las fórmulas básicas se definen de la siguiente manera (donde $n$ es el «BasePeriod»):

Figura del texto:

1. **Velocity Quotient (VQ)** – Measures the rate of price change.
VQ_i=\frac{Close_i-Close_{i-n}}{n}
Where:
- \(Close_i\) = current closing price
- \(Close_{i-n}\) = closing price \(n\) bars ago
- \(n\) = lookback period

2. **Kinetic Displacement (KD)** – Measures the deviation of the current price from its local mean.
KD_i=Close_i-SMA(Close,n)_i
Where:
- \(SMA(Close,n)_i\) = Simple Moving Average of the closing price over the last \(n\) periods.
3. **Energy Dispersion (ED)** – Acts as a dynamic volatility proxy, calculated as the standard deviation of the closing price.
ED_i=\sqrt{\frac{\sum_{j=0}^{n-1}\left(Close_{i-j}-SMA_i\right)^2}{n}}
Where:
- \(SMA_i\) = local Simple Moving Average at bar \(i\).

4. **Phase Velocity (PV)** – Tracks the immediate momentum of the Velocity Quotient.
PV_i=VQ_i-VQ_{i-1}
Where:
- \(VQ_i\) = current Velocity Quotient
- \(VQ_{i-1}\) = previous Velocity Quotient

// Or

1. Velocity Quotient (VQ)
VQ(i) = (Close(i) - Close(i-n)) / n

2. Kinetic Displacement (KD)
KD(i) = Close(i) - SMA(Close, n)

3. Energy Dispersion (ED)
                n-1
               -----
               \
ED(i) = sqrt(  /    (Close(i-j) - SMA(i))² / n )
               -----
               j=0

4. Phase Velocity (PV)
PV(i) = VQ(i) - VQ(i-1)

Normalización mediante la puntuación Z: dado que estas cuatro métricas tienen escalas diferentes (por ejemplo, precios frente a tipos puros), se normalizan utilizando una puntuación Z móvil a lo largo de un «ZScorePeriod» definido antes de sumarlas en el «Raw_KCI».

Arquitectura del sistema y mapa de búfer unificado

Para evitar los habituales errores de «índice fuera de límites» o de desajuste de búfer durante las llamadas a CopyBuffer(), el KCI se ajusta estrictamente al siguiente mapa de búfer unificado. Esta asignación es coherente en las declaraciones #property, SetIndexBuffer() y la integración de EA.

Índice del búfer	Nombre del búfer	Tipo	Finalidad
0	KCI_Main	INDICATOR_DATA	Línea del oscilador polarizado visual
1	KCI_Color	ÍNDICE_DE_COLORES_DEL_INDICADOR	Asignación dinámica de colores para la línea principal
2	Señal_Compra	INDICATOR_DATA	Señal de compra (1,0 = Compra, 0,0 = Neutral)
3	Señal_Venta	DATOS_DEL_INDICADOR	Señal de venta (1,0 = Venta, 0,0 = Neutral)
4	VQ_interno	CÁLCULOS_DEL_INDICADOR	Matriz del cociente de velocidad
5	Internal_KD	CÁLCULOS_DE_INDICADORES	Matriz de desplazamiento cinético
6	Internal_ED	CÁLCULOS_DE_INDICADORES	Matriz de dispersión de energía (utilizada para SL/TP)
7	Internal_PV	CÁLCULOS_DE_INDICADORES	Matriz de velocidad de fase
8	Raw_KCI	CÁLCULOS_DE_INDICADORES	Suma de matrices normalizadas

Explicación del código: Integración de EA y gestión de riesgos

Al llamar a KCI desde un EA, el código debe gestionar el ciclo de vida del identificador del indicador, verificar que CopyBuffer haya recuperado correctamente los datos y normalizar todos los cálculos de precios para el Stop Loss (SL) y el Take Profit (TP) de acuerdo con los dígitos del símbolo.

A continuación se muestra la plantilla de integración de EA corregida y robusta:

#include <Trade\Trade.mqh>
CTrade trade;

int handle_kci;
datetime last_bar_time = 0;
double buf_buy[], buf_sell[], buf_ed[];

int OnInit()
{
    // Inicializar el identificador de KCI
    handle_kci = iCustom(_Symbol, _Period, "KCI", 50, 2.0, 14);
    
    if(handle_kci == INVALID_HANDLE) 
    {
        Print("Failed to create KCI handle!");
        return(INIT_FAILED);
    }
    
    ArraySetAsSeries(buf_buy, true);
    ArraySetAsSeries(buf_sell, true);
    ArraySetAsSeries(buf_ed, true);
    
    return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason)
{
    if(handle_kci != INVALID_HANDLE)
        IndicatorRelease(handle_kci);
}

void OnTick()
{
    datetime current_time = (datetime)SeriesInfoInteger(_Symbol, _Period, SERIES_LASTBAR_DATE);
    if(current_time == last_bar_time) return; 
    
    // Filtro básico: solo una posición por símbolo
    if(PositionsTotal() > 0) 
    {
        for(int i = PositionsTotal() - 1; i >= 0; i--)
        {
            if(PositionGetSymbol(i) == _Symbol) return; 
        }
    }

    // Recuperar datos (búfer 2 = compra, búfer 3 = venta, búfer 6 = ED)
    if(CopyBuffer(handle_kci, 2, 1, 1, buf_buy) <= 0) return;
    if(CopyBuffer(handle_kci, 3, 1, 1, buf_sell) <= 0) return;
    if(CopyBuffer(handle_kci, 6, 1, 1, buf_ed) <= 0) return;

    // Bloquear la hora SOLO después de que los datos se hayan copiado correctamente
    last_bar_time = current_time;

    double dynamic_volatility = buf_ed[0];
    if(dynamic_volatility == 0) return;

    double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
    int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
    double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
    double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

    // Lógica de ejecución con stop loss de volatilidad dinámica normalizada
    if(buf_buy[0] == 1.0)
    {
        double sl = NormalizeDouble(ask - (dynamic_volatility * 1.5), digits);
        double tp = NormalizeDouble(ask + (dynamic_volatility * 3.0), digits);
        trade.Buy(0.01, _Symbol, ask, sl, tp, "KCI Buy");
    }
    
    if(buf_sell[0] == 1.0)
    {
        double sl = NormalizeDouble(bid + (dynamic_volatility * 1.5), digits);
        double tp = NormalizeDouble(bid - (dynamic_volatility * 3.0), digits);
        trade.Sell(0.01, _Symbol, bid, sl, tp, "KCI Sell");
    }
}

Rendimiento y limitaciones

Para garantizar unas expectativas realistas, los desarrolladores deben tener en cuenta las siguientes limitaciones estructurales:

1. Dependencia del volumen de ticks: En el caso del Forex y los CFD, «tick_volume» representa la frecuencia de las variaciones de precio, no la liquidez real. La métrica de compresión volumétrica puede comportarse de forma diferente en las bolsas centralizadas (acciones/futuros), donde se dispone del volumen real.

2. Vulnerabilidad a la reversión a la media: al ser un oscilador acotado, el KCI tiene como objetivo detectar el agotamiento. En un mercado con una tendencia fuerte, puede generar señales de reversión prematuras consecutivas. Debe combinarse con un filtro de tendencia en un marco temporal superior (por ejemplo, la EMA 200).

3. Ruido en los marcos temporales cortos: el uso de este indicador en M1 o M5 expone la lógica al ruido de la microestructura. La normalización mediante la puntuación Z requiere una distribución estable, que se encuentra mejor en M15 y marcos temporales superiores.

Conclusión

El Índice de Compresión Cinética ofrece una alternativa transparente y calculada de forma nativa al apilamiento de múltiples indicadores estándar. Al mostrar tanto las señales direccionales en las barras cerradas como un indicador dinámico de volatilidad (dispersión de energía) a través de un mapa de búfer unificado, sirve como un componente estructural fiable para los asesores expertos de MQL5.

Implementación en el gráfico: (KCI personalizado)