KCI Volatility Distance - Indikator für den MetaTrader 5

Abbildung 1

Abbildung 3

Einfache Parametereinstellungen

Abbildung 2

Anleitung zur Integration des KCI-Volatilitätsabstands in einen Expert Advisor (EA)

Es gibt zwei Hauptmethoden zur Integration dieses Algorithmus in einen EA. Die erste Methode (Embedded OOP) wird für maximale CPU-Effizienz und die Erfassung von Datensätzen für maschinelles Lernen dringend empfohlen. Die zweite Methode (iCustom Invocation) eignet sich für schnelle Prototypentests.

Methode 1: Direkte Nutzung über eine eingebettete OOP-Klasse (ultraleicht)

• Bei dieser Methode wird die Engine direkt in den EA eingebettet, ohne externe Indikatoren aufzurufen. Der Code wird auf globaler Ebene platziert, in „OnInit“ initialisiert und in „OnTick“ ausgeführt.

// --- 1. Platzieren Sie die OOP-Klasse am Anfang der EA-Datei oder binden Sie sie über #include ein ---
class CKCIDirectionalMatrix
  {
   // (Fügen Sie hier die vollständige Implementierung der Klasse „CKCIDirectionalMatrix“ ein)
   // ...
  };

// --- 2. Globale Objektinstanz deklarieren ---
CKCIDirectionalMatrix MatrixEngine;

// EA-Eingabeparameter
input int MatrixPeriod = 14;
input double EntryThreshold = 0.0050; // Schwellenwert für die Momentum-Stärke

// --- 3. Die Engine in OnInit() initialisieren ---
int OnInit()
  {
   if(!MatrixEngine.Init(MatrixPeriod))
      return(INIT_PARAMETERS_INCORRECT);

   return(INIT_SUCCEEDED);
  }

// --- 4. Die Kernlogik in OnTick() ausführen ---
void OnTick()
  {
   // Arrays zum Speichern der aktuellen Marktpreisdaten vorbereiten
   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;

   // Arrays müssen als Zeitreihen konfiguriert werden (Index 0 = aktuellster Balken)
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);

   // Berechne die Matrixausgabe für den zuletzt geschlossenen Balken (Index 1)
   double current_matrix_strength = MatrixEngine.Calculate(1, high, low, close);

   // --- A. Modul für maschinelles Lernen / Merkmalsextraktion ---
   // Gib „current_matrix_strength“ in dein neuronales Netzwerk ein
   // oder einen KI-Merkmalsvektor als Eingabevariable.

   // --- B. Modul für Handelsentscheidungen (Signalfilterung) ---
   if(current_matrix_strength > EntryThreshold)
     {
      // Momentum-Prüfung bestanden.
      // Der Markttrend wird als ausreichend stark eingeschätzt.

      // -> Führen Sie hier KAUF- oder VERKAUF-Aufträge entsprechend aus
      //    zur Richtungsstrategie Ihres EAs.

      // -> Alternativ können Sie diesen Wert verwenden, um dynamisch
      //    Passen Sie den Abstand im Smart Grid oder andere adaptive Parameter an.
     }
  }

Methode 2: Aufruf über iCustom()

Falls Sie die .mq5-Datei des Indikators „KCI Volatility Distance“ separat veröffentlichen und möchten, dass der EA sie über den Standard-Indikatorpuffer einliest.

Codeausschnitt

// --- 1. Deklarieren Sie das Indikator-Handle im globalen Bereich ---
int MatrixHandle;

// EA-Eingabeparameter
input int MatrixPeriod = 14;

// --- 2. Erstellen des Indikator-Handles in OnInit() ---
int OnInit()
  {
   // Sicherstellen, dass der Dateiname des Indikators exakt übereinstimmt
   // die Datei im Ordner „Indicators“.
   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. Indikator-Pufferdaten in OnTick() einlesen ---
void OnTick()
  {
   double MatrixBuffer[];
   ArraySetAsSeries(MatrixBuffer, true);

   // Die beiden letzten Werte aus Puffer 0 (KCI-VD-Leitung) abrufen
   if(CopyBuffer(MatrixHandle, 0, 0, 2, MatrixBuffer) <= 0)
     {
      Print("Failed to copy matrix buffer data.");
      return;
     }

   // Matrixwert der zuletzt geschlossenen Kerze
   double current_matrix_strength = MatrixBuffer[1];

   // Matrixwert der sich gerade bildenden Kerze (in Echtzeit)
   double previous_matrix_strength = MatrixBuffer[0];

   // --- Logik für Handelsentscheidungen ---
   if(current_matrix_strength > previous_matrix_strength)
     {
      // Die Dynamik nimmt zu.
      // -> Verwenden Sie dies als zusätzliche Bestätigung für
      //    Den Take-Profit-Abstand vergrößern.
      //
      // -> Alternativ können Sie damit eine adaptive Funktion auslösen
      //    Anpassung des Trailing Stops.
     }
  }

Angesichts der hochgradig anpassungsfähigen und CPU-schonenden Architektur des „KCI Volatility Distance“ geht sein Potenzial über herkömmliche visuelle Indikatoren hinaus. Die Flexibilität seines auf objektorientierter Programmierung (OOP) basierenden Codes ermöglicht es, ihn als Engine für eine Vielzahl fortgeschrittener algorithmischer Szenarien einzusetzen.

1. Anti-Stop-Hunting-Abwehrsystem (dynamisches SL & TP)

Plötzliche Kursbewegungen sind oft eher Liquiditätsfallen (Liquidity Grab oder Stop-Hunt) als echte Trends. Der KCI Volatility Distance kann diese Anomalien erkennen.

• Logik: Wenn es zu einem starken Kurssprung kommt, die Matrix-Werte jedoch ein geringes Maß an Effizienz (Richtung) anzeigen, erkennt der EA dies als potenzielles Stop-Hunting.
• Umsetzung: Anstatt einen Cut-Loss auszuführen oder einen statischen SL zu setzen, erweitert der EA automatisch den SL-Schutz (Dynamic SL), bis die Volatilität nachlässt, und sucht dann nach einem optimaleren Wiedereinstiegspunkt.

// Beispiel: Erkennung von Volatilitätsanomalien (Anti-Stop-Hunt-Filter)
double matrix_value = MatrixEngine.Calculate(1, high, low, close);

// Der ATR dient als Referenzwert für die Basisvolatilität
double atr_baseline = iATR(_Symbol, _Period, 14);

// Erkennung einer im Verhältnis zum erwarteten Volatilitätsbereich ungewöhnlichen Marktexpansion
if(matrix_value > (atr_baseline * 2.5))
  {
   Print("Warning: Volatility anomaly detected. Quantum SL Defense activated.");

   // Schutzmaßnahmen:
   // - Das Eröffnen neuer Positionen verhindern.
   // - Den Stop-Loss bestehender Positionen dynamisch erweitern
   //   um die Wahrscheinlichkeit von Stop-Hunt-Ereignissen zu verringern.
   ModifySLToSafeZone(matrix_value);
  }

2. Adaptives Smart-Grid- und Mittelwertbildungsalgorithmus

Eine der Schwächen des Standard-Grid-Systems ist sein starrer Abstand (Schritte), was besonders gefährlich ist, wenn ein einseitiger Trend stark ausgeprägt ist.

• Logik: Wandelt die Grid-Abstände von statischen Werten (Punkten) in dynamische Koeffizienten um, die mit dem Ausgabewert des KCI-Volatilitätsabstands multipliziert werden.
• Umsetzung: Bei Seitwärtsbewegung des Marktes (die Matrix dehnt sich aus) vergrößert sich auch der Abstand zwischen den Grid-Linien. Dies verhindert, dass der EA zu viele Positionen in einem einzigen Konsolidierungsbereich eröffnet, wodurch er sehr sicher gegen Drawdowns bei Vermögenswerten mit starken Schwankungen wie XAUUSD, BTC oder dem US30 gewappnet ist.

// Beispiel: Berechnung des Abstands im adaptiven Raster
input double GridMultiplier = 1.5;

// Die aktuellste Messung der Richtungsmatrix abrufen
double current_matrix = MatrixEngine.Calculate(0, high, low, close);

// Den adaptiven Gitterabstand anhand des Matrixwerts ableiten
// als dynamische Darstellung der aktuellen Marktbedingungen
double dynamic_grid_step = current_matrix * GridMultiplier;

// Eine neue Grid-Position erst eröffnen, nachdem sich der Markt bewegt hat
// jenseits des dynamisch berechneten Abstandsschwellenwerts
if(MathAbs(CurrentPrice - LastOrderPrice) >= dynamic_grid_step)
  {
   // Den nächsten Grid-/Mittelwertbildungsauftrag ausführen
   ExecuteGridOrder();
  }

3. Merkmalsnormalisierung für Machine-Learning-
(ML)

Module Neuronale Netzmodelle benötigen normalisierte Eingabedaten, um Muster genau zu erkennen, ohne durch Unterschiede in der Preisgenauigkeit zwischen Brokern oder Anlageklassen verzerrt zu werden (z. B. der starke Unterschied zwischen den WTI-Ölpreisen und weniger wichtigen Devisenpaaren).

• Logik: Innerhalb der KCI-Volatilitätsabstandsformel gibt es eine Berechnung des Effizienzverhältnisses (ER), die naturgemäß ein Skalenverhältnis von 0 bis 1 ergibt.
• Implementierung: Sie können die OOP-Klasse leicht modifizieren, um reine ER-Werte zurückzugeben. Dieses Array aus Matrixwerten wird in ein Array extrahiert und dient als sehr sauberes und rauschfreies Trainingsdatenset für den Pattern Learner.

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

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

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

//+------------------------------------------------------------------+
//| Initialisierung                                                   |
//+------------------------------------------------------------------+
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; // Sicherheitsausweichlösung
   return(true);
     }

//+------------------------------------------------------------------+
//| Kernberechnungsmodul (für CPU und Geschwindigkeit optimiert)              |
//| Hinweis: Arrays müssen als Serie festgelegt werden (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. Optimiertes Schleifenfenster ohne verschachtelte Funktionen ---
   for(int j = 0; j < m_kinetic_period; j++)
     {
      int curr_idx = index + j;
      
      // Optimierung der Vergleichsgeschwindigkeit für „True Range“ (Vermeidung von mehrstufigem MathMax)
      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);

      // Kursbewegung des Schlusskurses (Effizienzverhältnis)
      if(j < m_kinetic_period - 1)
        {
         path_length += MathAbs(close[curr_idx] - close[curr_idx + 1]);
        }
     }

   // --- 2. Berechnung des Wirkungsgrads ---
   double net_distance = MathAbs(close[index] - close[index + m_kinetic_period - 1]);
   
   if(path_length < net_distance) path_length = net_distance; // Logische Begrenzung
   if(path_length == 0.0)         path_length = m_point;      // Vermeidung von Division durch Null
   
   double efficiency_ratio = net_distance / path_length;

   // --- 3. Berechnung der Standardabweichung des 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; // Korrektur der Gleitkommagenauigkeit
   
   double std_TR = MathSqrt(variance);

   // --- 4. Ausgabe des Endwerts von KCI VD ---
   return(std_TR * (2.0 - efficiency_ratio));
  }

Visuelle Indikator-Datei (KCI_Volatility_Distance.mq5) --- Weitere Optionen ---

Speichern Sie diesen Code im Ordner „MQL5\Indicators\“. Dieser Indikator ist nun sehr übersichtlich, da er die OOP-Struktur aus der oben genannten .mqh-Datei aufruft.

Codeausschnitt

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

// Hauptmodul KCIVD einbinden
#include <KCIVD.mqh>

// --- Eingabe ---
input group "=== KCI Volatility Settings ==="
input int KineticPeriod = 14;   // Berechnungszeitraum (≥2)

// --- Puffer ---
double KVR_Buffer[];

// Globale Objektinstanz
CKCIVolatilityDistance kci_engine;

//+------------------------------------------------------------------+
//| Initialisierungsfunktion für benutzerdefinierte Indikatoren                         |
//+------------------------------------------------------------------+
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);
  }

//+------------------------------------------------------------------+
//| Iterationsfunktion für benutzerdefinierte Indikatoren                              |
//+------------------------------------------------------------------+
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);

   // Standard-Array als Serie festlegen
   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);

   // Rechenmaschine über ein OOP-Objekt ausführen
   for(int i = limit; i >= 0 && !IsStopped(); i--)
     {
      KVR_Buffer[i] = kci_engine.Calculate(i, high, low, close);
     }

   return(rates_total);
  }

Leitfaden zur funktionsübergreifenden Integration (Verwendung in EA/ML)

Mit der Klassenstruktur „CKCIVolatilityDistance“ können Sie diese direkt in jedem Expert Advisor verwenden, um maximale Leistung zu erzielen. Hier ist ein Beispiel für die logische Implementierung:

Integration in ein Machine-Learning-Modul (Merkmalsextraktion / Signalvalidierung)

Wenn Sie über ein neuronales Netzwerk oder ein Musterlernmodul verfügen, das eine Volatilitätsnormalisierung als Eingabemerkmal benötigt, können Sie den KCI-VD-Wert wie folgt extrahieren:

Code-Ausschnitt

#include <KCIVD.mqh>

CKCIVolatilityDistance KCI_ML;

int OnInit()
  {
   // Initialisierung der KCI-Volatilitätsabstands-Engine
   // mit dem gewünschten Berechnungszeitraum.
   KCI_ML.Init(14);

   return(INIT_SUCCEEDED);
  }

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

   // Eine ausreichende Menge an historischen Kursdaten kopieren
   // (z. B. die letzten 50 Balken) in lokale Arrays.
   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);

   // Berechne den KCI-Volatilitätsabstandswert für
   // der aktuelle Balken (Index 0) oder der zuletzt geschlossene Balken (Index 1).
   double kci_current_volatility = KCI_ML.Calculate(0, high, low, close);

   // „kci_current_volatility“ in das neuronale Netzwerk einspeisen
   // Merkmalsvektor zur Signalvalidierung oder -vorhersage.
  }

4. Multi-Symbol-Scanner (Dashboard-Indikator)

Da KCIDirectionalMatrix nicht auf iCustom angewiesen ist und lokalen Speicher schnell freigibt, eignet es sich perfekt als Signalsuchmaschine auf einem Multi-Symbol-Dashboard.

• Logik: Installieren Sie einen Dashboard-Indikator auf einem Chart, führen Sie die Matrixberechnungsschleife jedoch gleichzeitig für 20–30 verschiedene Symbole durch.
• Implementierung: Der Indikator durchsucht den gesamten Market Watch (Major, Cross, Metalle, Indizes), um Vermögenswerte zu identifizieren, deren Matrix-Werte sich verengen (Vorbereitung auf einen Ausbruch) oder die ein starkes Trendmomentum aufweisen. Dadurch wird verhindert, dass der Windows Server VPS verzögert reagiert oder die CPU überlastet wird.

// Beispiel: Markt-Scanning-Engine für verschiedene Anlageklassen
string symbols[] = {"EURUSD", "GBPUSD", "XAUUSD", "BTCUSD", "US30"};

for(int s = 0; s < ArraySize(symbols); s++)
  {
   // Die benötigten historischen Marktdaten laden
   // für das aktuelle Handelsinstrument.
   // ...

   // Die Richtungskraft berechnen
   // der zuletzt abgeschlossenen Kerze.
   double strength = MatrixEngine.Calculate(1, h, l, c);

   // Ein Handelssignal nur dann generieren, wenn die
   // Die Richtungsstärke überschreitet den konfigurierten Schwellenwert.
   if(strength > Threshold)
     {
      // Das Dashboard mit den erkannten Daten aktualisieren
      // Kauf-/Verkaufschance für das aktuelle Wertpapier.
      DrawDashboardSignal(symbols[s], strength);
     }
  }

Dies ist der Code für den KCI Volatility Distance; zumindest lässt sich dieser Code für verschiedene Zwecke nutzen. Sie können ihn mit Standard-MT5-Indikatoren und benutzerdefinierten MT5-Indikatoren weiterentwickeln, um eine noch höhere Genauigkeit und präzise Analyse zu erzielen.