KCI Standard: A Pure Kinematic Computing Engine for Market Singularity Detection - indicatore per MetaTrader 5

Abstract

Il Kinetic Compression Index (KCI) è un oscillatore personalizzato progettato per rilevare l'esaurimento del mercato ed eventi di compressione localizzati. Calcolando internamente le proprie metriche cinematiche anziché affidarsi a handle di indicatori standard esterni, il KCI riduce il sovraccarico e semplifica la gestione dei buffer per l’integrazione con gli Expert Advisor (EA). Questo articolo illustra in dettaglio i fondamenti matematici, l’architettura di sistema, la mappatura dei buffer e le guide pratiche all’integrazione per gli sviluppatori che intendono implementare questo strumento in MetaTrader 5.

Descrizione del problema

Gli obiettivi principali dell’architettura del KCI sono:

1. Ridurre la dipendenza dagli handle: calcolare le medie mobili e le deviazioni in modo nativo all’interno del ciclo dell’indicatore per ridurre al minimo l’uso di handle esterni.

2. Fornire metriche riproducibili: esporre metriche matematiche chiare e trasparenti (velocità, deviazione e dispersione) agli EA.

3. Garantire la sicurezza asincrona: creare buffer di segnali che effettuino la convalida solo sulle barre chiuse, proteggendo l’EA dal repainting intrabar e dai ritardi asincroni dei dati tick.

Teoria e fondamenti matematici

Il KCI si basa su quattro metriche fondamentali. Per garantire la piena riproducibilità, le formule principali sono definite come segue (dove $n$ è il Periodo di Base):

Figura testuale:

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)

Normalizzazione tramite Z-Score: poiché questi quattro indicatori hanno scale diverse (ad esempio, livelli di prezzo rispetto a tassi puri), vengono normalizzati utilizzando uno Z-Score mobile su un periodo definito (ZScorePeriod) prima di essere sommati nel Raw_KCI.

Architettura di sistema e mappa unificata dei buffer

Per evitare i comuni errori di «indice fuori limiti» o di buffer non corrispondente durante le chiamate a CopyBuffer(), il KCI aderisce rigorosamente alla seguente mappa unificata dei buffer. Questa mappatura è coerente tra le dichiarazioni #property, SetIndexBuffer() e l’integrazione EA.

Indice del buffer	Nome del buffer	Tipo	Scopo
0	KCI_Main	INDICATOR_DATA	Linea dell'oscillatore polarizzato visivo
1	KCI_Colore	INDICATOR_COLOR_INDEX	Mappatura dinamica dei colori per la linea principale
2	Segnale_Acquisto	INDICATOR_DATA	Segnale di acquisto (1,0 = Acquisto, 0,0 = Neutro)
3	Segnale_Vendita	DATI_INDICATORE	Segnale di vendita (1,0 = Vendita, 0,0 = Neutro)
4	VQ_interno	CALCOLI_INDICATORE	Matrice del quoziente di velocità
5	Internal_KD	CALCOLI_INDICATORI	Matrice dello spostamento cinetico
6	Internal_ED	CALCOLI_INDICATORI	Matrice di dispersione energetica (utilizzata per SL/TP)
7	Internal_PV	CALCOLI_INDICATORI	Matrice della velocità di fase
8	KCI_grezzo	CALCOLI_INDICATORI	Somma delle matrici normalizzate

Analisi dettagliata del codice: integrazione EA e gestione del rischio

Quando si richiama KCI da un EA, il codice deve gestire il ciclo di vita dell'handle dell'indicatore, verificare che CopyBuffer abbia recuperato correttamente i dati e normalizzare tutti i calcoli dei prezzi per lo Stop Loss (SL) e il Take Profit (TP) in base alle cifre del simbolo.

Ecco il modello corretto e robusto per l’integrazione con un EA:

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

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

int OnInit()
{
    // Inizializza l'handle 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 di base: una sola posizione per simbolo
    if(PositionsTotal() > 0) 
    {
        for(int i = PositionsTotal() - 1; i >= 0; i--)
        {
            if(PositionGetSymbol(i) == _Symbol) return; 
        }
    }

    // Recupera i dati (Buffer 2 = Acquisto, Buffer 3 = Vendita, Buffer 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;

    // Bloccare l'ora SOLO dopo che i dati sono stati copiati correttamente
    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);

    // Logica di esecuzione con stop loss basato sulla volatilità dinamica normalizzata
    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");
    }
}

Prestazioni e limitazioni

Per garantire aspettative realistiche, gli sviluppatori devono tenere conto delle seguenti limitazioni strutturali:

1. Dipendenza dal volume dei tick: per il Forex e i CFD, tick_volume rappresenta la frequenza delle variazioni di prezzo, non la liquidità effettiva. La metrica di compressione volumetrica potrebbe comportarsi in modo diverso sulle borse centralizzate (azioni/futures) dove è disponibile il volume reale.

2. Vulnerabilità alla regressione alla media: in quanto oscillatore con limiti definiti, il KCI mira a individuare i momenti di esaurimento. In un mercato con un trend forte, potrebbe generare segnali di inversione prematuri consecutivi. Dovrebbe essere abbinato a un filtro di trend su un timeframe più ampio (ad es. EMA 200).

3. Rumore nei timeframe bassi: l’utilizzo di questo indicatore su M1 o M5 espone la logica al rumore di microstruttura. La normalizzazione tramite Z-Score richiede una distribuzione stabile, che si riscontra meglio su M15 e timeframe superiori.

Conclusione

Il Kinetic Compression Index offre un’alternativa trasparente e calcolata internamente all’accatastamento di più indicatori standard. Mostrando sia i segnali direzionali sulle barre chiuse sia un indicatore dinamico della volatilità (Energy Dispersion) attraverso una mappa buffer unificata, funge da componente strutturale affidabile per gli Expert Advisor MQL5.

Implementazione sul grafico: (KCI Custom)