KCI Standard: A Pure Kinematic Computing Engine for Market Singularity Detection - Indikator für den MetaTrader 5

Zusammenfassung

Der Kinetic Compression Index (KCI) ist ein speziell entwickelter Oszillator, der dazu dient, Markterschöpfung und lokale Kompressionsereignisse zu erkennen. Da der KCI seine kinematischen Kennzahlen intern berechnet, anstatt auf externe Standardindikatoren zurückzugreifen, reduziert er den Overhead und vereinfacht die Pufferverwaltung für die Integration in Expert Advisors (EAs). Dieser Artikel beschreibt die mathematischen Grundlagen, die Systemarchitektur, die Pufferzuordnung sowie praktische Integrationsanleitungen für Entwickler, die dieses Tool in MetaTrader 5 implementieren möchten.

Problemstellung

Die Hauptziele der KCI-Architektur sind:

1. Reduzierung der Handle-Abhängigkeit: Berechnung von gleitenden Durchschnitten und Abweichungen direkt innerhalb der Indikatorschleife, um die Verwendung externer Handles zu minimieren.

2. Bereitstellung reproduzierbarer Kennzahlen: Bereitstellung sauberer, transparenter mathematischer Kennzahlen (Velocity, Deviation und Dispersion) für EAs.

3. Gewährleistung der asynchronen Sicherheit: Aufbau von Signalpuffern, die nur bei geschlossenen Balken validiert werden, um den EA vor einer Neudarstellung innerhalb eines Balkens und asynchronen Verzögerungen bei den Tick-Daten zu schützen.

Theorie und mathematische Grundlagen

KCI basiert auf vier grundlegenden Kennzahlen. Um vollständige Reproduzierbarkeit zu gewährleisten, sind die Kernformeln wie folgt definiert (wobei $n$ die Basisperiode ist):

Text Abbildung:

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)

Z-Score-Normalisierung: Da diese vier Kennzahlen unterschiedliche Skalen aufweisen (z. B. Kurswerte gegenüber reinen Zinssätzen), werden sie mithilfe eines gleitenden Z-Scores über einen definierten ZScorePeriod normalisiert, bevor sie zum Raw_KCI summiert werden.

Systemarchitektur und einheitliche Pufferzuordnung

Um die häufig auftretenden Fehler „Index Out of Bounds“ oder nicht übereinstimmende Puffer bei CopyBuffer()-Aufrufen zu vermeiden, hält sich der KCI strikt an die folgende einheitliche Pufferzuordnung. Diese Zuordnung ist über #property-Deklarationen, SetIndexBuffer() und die EA-Integration hinweg konsistent.

Pufferindex	Puffername	Typ	Zweck
0	KCI_Main	INDICATOR_DATA	Leitung für visuell polarisierten Oszillator
1	KCI_Farbe	INDIKATOR_FARBINDEX	Dynamische Farbabbildung für die Hauptlinie
2	Signal_Kauf	INDICATOR_DATA	Kaufsignal (1,0 = Kauf, 0,0 = Neutral)
3	Signal_Verkauf	INDIKATOR_DATEN	Verkaufssignal (1,0 = Verkauf, 0,0 = neutral)
4	Internal_VQ	INDIKATOR_BERECHNUNGEN	Velocity-Quotient-Array
5	Internal_KD	INDIKATOR_BERECHNUNGEN	Array „Kinetische Verschiebung“
6	Internal_ED	INDIKATOR_BERECHNUNGEN	Energiedispersions-Array (wird für SL/TP verwendet)
7	Internal_PV	INDIKATOR_BERECHNUNGEN	Phasengeschwindigkeits-Array
8	Raw_KCI	INDIKATOR_BERECHNUNGEN	Summe der normierten Matrizen

Code-Erläuterung: EA-Integration und Risikomanagement

Beim Aufruf von KCI aus einem EA muss der Code den Lebenszyklus des Indikator-Handles verwalten, überprüfen, ob „CopyBuffer“ die Daten erfolgreich abgerufen hat, und alle Kursberechnungen für Stop-Loss (SL) und Take-Profit (TP) entsprechend der Stellenanzahl des Symbols normalisieren.

Hier ist die korrigierte, robuste Vorlage für die EA-Integration:

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

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

int OnInit()
{
    // KCI-Handle initialisieren
    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; 
    
    // Grundfilter: nur eine Position pro Symbol
    if(PositionsTotal() > 0) 
    {
        for(int i = PositionsTotal() - 1; i >= 0; i--)
        {
            if(PositionGetSymbol(i) == _Symbol) return; 
        }
    }

    // Daten abrufen (Puffer 2 = Kauf, Puffer 3 = Verkauf, Puffer 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;

    // Die Zeit erst dann sperren, wenn die Daten erfolgreich kopiert wurden
    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);

    // Ausführungslogik mit normalisiertem dynamischem Volatilitäts-Stop-Loss
    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");
    }
}

Leistung und Einschränkungen

Um realistische Erwartungen zu gewährleisten, müssen Entwickler die folgenden strukturellen Einschränkungen berücksichtigen:

1. Abhängigkeit vom Tick-Volumen: Bei Devisen/CFDs stellt „tick_volume“ die Häufigkeit von Kursänderungen dar, nicht die tatsächliche Liquidität. Die Metrik zur Volumenkompression kann sich an zentralisierten Börsen (Aktien/Futures), an denen das tatsächliche Volumen verfügbar ist, anders verhalten.

2. Anfälligkeit für Mean-Reversion: Als begrenzter Oszillator zielt der KCI darauf ab, Erschöpfungsphasen zu erkennen. In einem starken, trendorientierten Markt kann er jedoch aufeinanderfolgende vorzeitige Umkehrsignale erzeugen. Er sollte daher mit einem Trendfilter für einen höheren Zeitrahmen (z. B. EMA 200) kombiniert werden.

3. Rauschen in niedrigen Zeitrahmen: Die Verwendung dieses Indikators auf M1 oder M5 setzt die Logik dem Rauschen der Mikrostruktur aus. Die Z-Score-Normalisierung erfordert eine stabile Verteilung, die besser auf M15 und darüber zu finden ist.

Fazit

Der Kinetic Compression Index bietet eine transparente, nativ berechnete Alternative zur Kombination mehrerer Standardindikatoren. Indem er sowohl Richtungssignale auf geschlossenen Kerzen als auch einen dynamischen Volatilitätsindikator (Energy Dispersion) über eine einheitliche Pufferkarte darstellt, dient er als zuverlässige strukturelle Komponente für MQL5-Expert Advisors.

Implementierung im Chart: (KCI Custom)