KCI Directional Matrix - Indikator für den MetaTrader 5

• SZENARIO B: Der bärische Durchbruch (VERKAUF)
• Überprüfen Sie die goldene Linie: Sie muss nach OBEN kreuzen und die 20er-Marke durchbrechen. (Ja, sie steigt auch bei Abwärtstrends an, da die Abwärtsdynamik zunimmt!)
  
• Überprüfen Sie die gestrichelten Linien: Die rote Linie (-KDI) muss die blaue Linie (+KDI) nach OBEN kreuzen.
  
• Ausführung: Eröffnen Sie eine VERKAUF -Position.
  

• SZENARIO C: Die Gewinnmitnahme (AUSSTIEG)
• Beobachten Sie die goldene Linie: Sie sind bereits in einer Position, und die goldene Linie berührt oder überschreitet die 80er -Marke.
  
• Ausführung: Verschieben Sie Ihren Stop-Loss auf Breakeven, aktivieren Sie einen engen Trailing-Stop oder schließen Sie die Position, um Gewinne zu sichern.
  

• Kauf-Einstiegslogik (bullisch):
• KDI_Plus kreuzt KDI_Minus nach oben (Cross-over).
• Filter: KCI_Main muss über der 20er-Marke liegen (was bestätigt, dass sich der Markt außerhalb der Kompressions-/Seitwärtszone befindet).

• Verkaufseinstiegslogik (bärisch):
• KDI Minus kreuzt KDI Plus nach oben (Crossover).
• Filter: KCI_Main muss über dem Niveau 20 liegen.

• Ausstiegs-/Take-Profit-/Trailing-Logik:
• Wenn KCI_Main das Niveau 80 erreicht (extremer Trend), sollte der EA einen engen Trailing-Stop aktivieren oder einen teilweisen Take-Profit ausführen, da die Trendenergie ihr Maximum erreicht hat und das Potenzial für eine Korrektur besteht.

//+------------------------------------------------------------------+
//|                                                 EA_KCI_iCustom.mq5 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Ritz"
#property version   "1.00"

int kci_handle;
double KCI_Main[], KDI_Plus[], KDI_Minus[];

int OnInit()
  {
   // Erstellen Sie den Handle für den benutzerdefinierten Indikator.
   // Stelle sicher, dass sich „KCI-Directional_X.ex5“ an folgendem Speicherort befindet
   // im Verzeichnis „MQL5/Indicators“.
   kci_handle = iCustom(_Symbol, _Period, "KCI-Directional_X", 9, 30, 1.5);

   if(kci_handle == INVALID_HANDLE)
     {
      Print("Failed to load the KCI-DX indicator.");
      return(INIT_FAILED);
     }

   // Indikatorpuffer als Zeitreihen konfigurieren
   // (Index 0 = aktueller Balken).
   ArraySetAsSeries(KCI_Main, true);
   ArraySetAsSeries(KDI_Plus, true);
   ArraySetAsSeries(KDI_Minus, true);

   return(INIT_SUCCEEDED);
  }

void OnTick()
  {
   // Die aktuellen Indikatorwerte abrufen
   // (aktuelle Kerze und die zuletzt geschlossene Kerze).
   if(CopyBuffer(kci_handle, 0, 0, 2, KCI_Main) <= 0)
      return;

   if(CopyBuffer(kci_handle, 1, 0, 2, KDI_Plus) <= 0)
      return;

   if(CopyBuffer(kci_handle, 2, 0, 2, KDI_Minus) <= 0)
      return;

   // ------------------------------------------------------------
   // KCI-DX-Handelslogik
   // Alle Handelsentscheidungen basieren auf der zuletzt abgeschlossenen Kerze
   // (Index 1), um Signale der sich noch bildenden Kerze zu vermeiden.
   // ------------------------------------------------------------

   // Ermitteln, ob sich der Markt in einer Trendphase befindet.
   bool isTrending = KCI_Main[1] > 20.0;

   // Erkennen eines bullischen Richtungs-Crossovers.
   bool buySignal  = (KDI_Plus[1] > KDI_Minus[1]) &&
                     (KDI_Plus[2] <= KDI_Minus[2]);

   // Einen bärischen Richtungs-Crossover erkennen.
   bool sellSignal = (KDI_Minus[1] > KDI_Plus[1]) &&
                     (KDI_Minus[2] <= KDI_Plus[2]);

   // Eine extreme Trendausweitung erkennen.
   bool isExtreme  = KCI_Main[1] >= 80.0;

   // Beispiel für eine Logik zur Handelsausführung.
   if(isTrending && buySignal)
     {
      Print("KCI-DX BUY signal detected.");

      // Ausführen Ihrer KAUF-Order
      // (OrderSend oder CTrade::Buy) hier.
     }
   else if(isTrending && sellSignal)
     {
      Print("KCI-DX SELL signal detected.");

      // Ausführen Ihrer VERKAUF-Order
      // (OrderSend oder CTrade::Sell) hier.
     }

   // Optionale Handelssteuerung bei starken Markttrends.
   if(isExtreme)
     {
      Print("Extreme trend detected. Consider activating a trailing stop or managing existing positions.");
     }
  }

Beispiel für EA-Code mit eingebetteten Berechnungen (direkt eingebettet) (eingebettet in die EA-Engine „KCI-N Matrix“)

Bei dieser Methode wird Ihr mathematischer Algorithmus direkt in den EA integriert, ohne dass externe Indikator-Dateien erforderlich sind. Da die Berechnung historische Daten für den Z-Score benötigt, verwenden wir eine spezielle Funktion innerhalb des EA, um das Kurs-Array zu verarbeiten.

Codeausschnitt:

//+------------------------------------------------------------------+
//|                                              EA_KCI_Embedded.mq5 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Ritz"
#property version   "1.00"

input int    InpBasePeriod   = 9;
input int    InpZScorePeriod = 30;
input double InpSensitivity  = 1.5;

// Struktur zur Rückgabe aller drei KCI-DX-Werte
// aus einer einzigen Berechnung.
struct KCI_Result
  {
   double main;
   double plus;
   double minus;
  };

// Berechnung des internen Z-Werts, der für
// dynamische Normalisierung.
double EmbeddedZScore(double &data_array[], int period)
  {
   if(period < 2)
      return 0.0;

   double sum = 0.0;
   double sum_sq = 0.0;

   for(int i = 0; i < period; i++)
     {
      sum += data_array[i];
      sum_sq += data_array[i] * data_array[i];
     }

   double mean = sum / period;
   double variance = (sum_sq / period) - (mean * mean);

   if(variance <= 1 e-10)
      return 0.0;

   return (data_array[0] - mean) / MathSqrt(variance);
  }

// Berechne die KCI-DX-Werte für einen angegebenen
// historischer Balken (Shift).
KCI_Result CalculateKCI(int shift)
  {
   KCI_Result res;
   res.main = 0.0;
   res.plus = 0.0;
   res.minus = 0.0;

   // Ausreichend viele historische Schlusskurse abrufen
   // sowohl für den Basiszeitraum als auch für das Z-Score-Fenster.
   int required_bars = InpZScorePeriod + InpBasePeriod;

   double close[];
   ArraySetAsSeries(close, true);

   if(CopyClose(_Symbol, _Period, shift, required_bars, close) < required_bars)
      return res;   // Unzureichende historische Daten.

   double raw_plus[];
   double raw_minus[];
   double raw_trend[];

   ArrayResize(raw_plus, InpZScorePeriod);
   ArrayResize(raw_minus, InpZScorePeriod);
   ArrayResize(raw_trend, InpZScorePeriod);

   // ------------------------------------------------------------
   // Phase 1:
   // Kinematische Richtungsermittlung
   // ------------------------------------------------------------
   for(int i = 0; i < InpZScorePeriod; i++)
     {
      double path_len = 0.000001;
      double net_up = 0.0;
      double net_dn = 0.0;
      double mean_p = 0.0;

      for(int j = 0; j < InpBasePeriod; j++)
        {
         double diff = close[i + j] - close[i + j + 1];

         path_len += MathAbs(diff);

         if(diff > 0)
            net_up += diff;
         else
            net_dn -= diff;

         mean_p += close[i + j];
        }

      mean_p /= InpBasePeriod;

      double var_p = 0.0;

      for(int j = 0; j < InpBasePeriod; j++)
         var_p += MathPow(close[i + j] - mean_p, 2);

      double energy = MathSqrt(var_p / InpBasePeriod);

      raw_plus[i]  = (net_up / path_len) * energy;
      raw_minus[i] = (net_dn / path_len) * energy;
      raw_trend[i] = (MathAbs(net_up - net_dn) / path_len) * energy;
     }

   // ------------------------------------------------------------
   // Phase 2:
   // Dynamische Sigmoid-Normalisierung
   // ------------------------------------------------------------
   double z_plus  = EmbeddedZScore(raw_plus, InpZScorePeriod);
   double z_minus = EmbeddedZScore(raw_minus, InpZScorePeriod);
   double z_trend = EmbeddedZScore(raw_trend, InpZScorePeriod);

   res.plus  = 100.0 / (1.0 + MathExp(-InpSensitivity * z_plus));
   res.minus = 100.0 / (1.0 + MathExp(-InpSensitivity * z_minus));
   res.main  = 100.0 / (1.0 + MathExp(-InpSensitivity * z_trend));

   return res;
  }

void OnTick()
  {
   // Berechne die KCI-DX-Werte für die
   // die beiden zuletzt abgeschlossenen Kerzen.
   KCI_Result kci_current = CalculateKCI(1);
   KCI_Result kci_prev    = CalculateKCI(2);

   // ------------------------------------------------------------
   // Beispiel für eine Handelslogik
   // Erkennen eines bullischen Richtungs-Crossovers.
   // ------------------------------------------------------------
   bool buySignal =
      (kci_current.plus > kci_current.minus) &&
      (kci_prev.plus <= kci_prev.minus);

   // Handelslogik nur ausführen, wenn der Markt
   // befindet sich in einem gültigen Trendzustand.
   if(kci_current.main > 20.0 && buySignal)
     {
      Print("Embedded KCI-DX detected a BUY signal.");

      // Ausführen Ihrer KAUF-Order
      // (OrderSend oder CTrade::Buy) hier.
     }
  }

Empfehlungen für optimale Ergebnisse

Bevor Sie den EA kompilieren und im Handel einsetzen, sollten Sie diese bewährten Vorgehensweisen beachten, um das Beste aus der KCI-Directional-Matrix herauszuholen:

• Flexibilität bei den Vermögenswerten: Die Standardparameter (BasePeriod=9, ZScorePeriod=30) reagieren sehr schnell und erzielen bei den wichtigsten Währungspaaren außergewöhnlich gute Ergebnisse. Wenn Sie diese Methode jedoch auf hochvolatile Instrumente wie Gold (XAUUSD), Kryptowährungen (BTC/ETH) oder Indizes anwenden, sollten Sie erwägen, den ZScorePeriod-Wert leicht zu erhöhen (z. B. auf 40 oder 50), um übermäßiges Rauschen herauszufiltern.

• Algorithmische Optimierung: Für EA-Entwickler, die komplexe oder Systeme mit mehreren Symbolen erstellen, wird die Verwendung der oben beschriebenen „Embedded Calculation“-Methode dringend empfohlen. Sie hält die CPU-Auslastung unglaublich gering und stellt sicher, dass Ihr Expert Advisor vollständig eigenständig bleibt, ohne dass externe Indikatoraufrufe erforderlich sind.

• Kombination für optimale Ergebnisse: KCI-DX ist eine spezielle Engine für Kinematik und Volatilität. Sie liefert zwar bereits für sich genommen eine hervorragende Richtungsneigung, entfaltet ihr volles Potenzial jedoch erst in Kombination mit Ihren bevorzugten strukturellen Filtern (wie Unterstützungs-/Widerstandszonen) oder Detektoren für Volumenanomalien, um den endgültigen Einstieg zu validieren.

Abschließende Bemerkung

Anmerkung des Autors / Fazit: Vielen Dank, dass Sie sich mit der KCI-Directional Matrix beschäftigt haben. Diese Codebasis wurde mit dem klaren Ziel entwickelt, der MQL5-Community ein ressourcenschonendes, mathematisch fundiertes und hochgradig anpassungsfähiges Analysewerkzeug zur Verfügung zu stellen. Ganz gleich, ob Sie als manueller Trader nach präzisen Momentum-Erschöpfungspunkten suchen oder als Entwickler maschinenlesbare Daten in einen Expert Advisor integrieren – ich hoffe, dass dieser Indikator als solide Grundlage für Ihre Projekte dient.

Wenn Sie diesen Code für Ihre Handelssysteme als wertvoll erachten, können Sie gerne eine Bewertung hinterlassen, Ihre kreativen Anpassungen teilen oder im Diskussionsbereich unten eine Frage stellen. Lassen Sie uns gemeinsam die Grenzen des algorithmischen Handels weiter verschieben!

Viel Spaß beim Programmieren und viel Erfolg beim Trading – Ritz