Entwicklung des Price Action Analysis Toolkit (Teil 22): Korrelation Dashboard

Inhalt

• Einführung
• Überblick über die Strategie
• MQL5 Code Zerlegung
• Ergebnisse
• Schlussfolgerung

Einführung

Die Korrelation ist ein statistisches Maß dafür, wie sich zwei Variablen im Verhältnis zueinander bewegen. Die Finanzmärkte spiegeln das Ausmaß wider, in dem zwei Instrumente gemeinsam steigen und fallen (positive Korrelation) oder in entgegengesetzter Richtung (negative Korrelation). Wichtig ist, dass die Korrelation Beziehungen beschreibt, keine Kausalität.
In meinem vorherigen Artikel habe ich gezeigt, wie man die EURUSD-GBPUSD-Korrelation mithilfe von Python-Bibliotheken darstellt. Jetzt führe ich Sie durch die Erstellung eines nutzerdefinierten Expert Advisors, der Korrelationsanalysen direkt in MetaTrader 5 mit praktischen On-Chart-Visualisierungen liefert. Dieses Tool erstellt ein Live-Dashboard, das Korrelationswerte für verschiedene Instrumente anzeigt: Währungen, Rohstoffe und mehr, über einen ausgewählten Zeitrahmen.
Durch die Verwendung dieses Dashboards erhalten Händler ein tieferes Verständnis dafür, wie Preisbewegungen auf verschiedenen Märkten zusammenwirken. Ob sich die Instrumente im Tandem bewegen, stark divergieren oder sich unabhängig voneinander verhalten, diese Erkenntnis hilft uns bei:

• Steuerung des Portfoliorisikos (durch Vermeidung eines übermäßigen Engagements in korrelierten Geschäften)
• Identifizierung potenzieller Absicherungen oder Paarverkäufe
• Verbesserung der Diversifizierung
• Erkennen von Verschiebungen in der Marktdynamik, wenn sich die Korrelationen ändern.

Abb. 1. Paar-Beziehungen

Das erste Diagramm zeigt, wie sich EURUSD und GBPUSD tendenziell gemeinsam bewegen: Wenn EURUSD steigt, steigt auch GBPUSD. Man spricht hier von einer starken positiven Korrelation oder einem direkten Verhältnis. Das zweite Diagramm zeigt, dass sich EURUSD und USDCHF in entgegengesetzte Richtungen bewegen: Während der EURUSD steigt, fällt der USDCHF. Das ist eine starke negative Korrelation (ein umgekehrtes Verhältnis). Wenn sich zwei Paare weder gemeinsam noch gegenläufig bewegen, sind sie unkorreliert oder unabhängig.

Überblick über die Strategie

Der Correlation Dashboard EA zieht kontinuierlich die letzten N Schlusskurse für jedes Paar in unsere Liste und wandelt sie in einfache Resultate um. Anschließend wird das Pearson r für jedes einzelne Instrumentenpaar berechnet und diese Werte als Heatmap-Matrix mit farbigen Zellen, die Stärke und Vorzeichen anzeigen, dargestellt. Der EA überlagert jeden r-Wert und klassifiziert ihn als stark positiv, moderat, keine Korrelation, moderat negativ oder stark negativ. Es druckt eine Interpretation mit maßgeschneiderten Ratschlägen - Absicherung, Bestätigung, Diversifizierung oder Streuung - und schlägt Alarm, wenn eine Korrelation Ihren Schwellenwert überschreitet.

Auf einen Blick sehen Sie, welche Märkte sich gemeinsam bewegen, welche gegenläufig sind und welche unabhängig bleiben, sodass Sie Ihre Positionen mit Zuversicht anpassen können. Wir berechnen den Pearson-Korrelationskoeffizienten (r) wie folgt. Hier ist der MQL5-Code, der die Berechnung durchführt:

//+------------------------------------------------------------------+
//| Pearson correlation                                              |
//+------------------------------------------------------------------+
double CalcCorrelation(const string s1, const string s2)
{
   double a1[], a2[];
   // Fetch closing prices
   if(CopyClose(s1, TimeFrame, 0, LookbackBars, a1) < LookbackBars ||
      CopyClose(s2, TimeFrame, 0, LookbackBars, a2) < LookbackBars)
      return(0);

   int n = LookbackBars - 1;
   double r1[], r2[];
   ArrayResize(r1, n);
   ArrayResize(r2, n);

   // Compute simple returns
   for(int k = 1; k < LookbackBars; k++)
   {
      r1[k-1] = (a1[k] - a1[k-1]) / a1[k-1];
      r2[k-1] = (a2[k] - a2[k-1]) / a2[k-1];
   }

   // Calculate means
   double m1 = AverageArray(r1);
   double m2 = AverageArray(r2);

   // Build covariance numerator and variances
   double num = 0, d1 = 0, d2 = 0;
   for(int i = 0; i < n; i++)
   {
      double da = r1[i] - m1;
      double db = r2[i] - m2;
      num += da * db;      // covariance sum
      d1  += da * da;      // variance of series 1
      d2  += db * db;      // variance of series 2
   }

   // Return r (or 0 if division by zero)
   return (d1 > 0 && d2 > 0) ? num / MathSqrt(d1 * d2) : 0;
}

• Starke positive Korrelation (r >/= 0,8)

Beispiel: EURUSD und GBPUSD, r = 0,85
Interpretation: Wenn der EURUSD um 1 % steigt, tendiert der GBPUSD im Durchschnitt um 0,85 % nach oben. Ein Kaufsignal für EURUSD wird durch GBPUSD effektiv verstärkt, sodass Sie beide als ein einziges Cluster behandeln, gegenläufige Positionen vermeiden und in Betracht ziehen, das eine als Absicherung für das andere zu verwenden.

• Starke negative Korrelation (r < oder = -0,8)

Beispiel: EURUSD und USDCHF, r = -0,92
Interpretation: Ein Anstieg des EURUSD um 1% geht mit einem Rückgang des USDCHF um 0,92% einher. Sie können Intermarket-Spreads (Kaufpreis EURUSD, Verkaufspreis USDCHF) einsetzen, um relative Bewegungen zu erfassen und gleichzeitig ein direktionales Engagement zu neutralisieren, oder Sie können auf Divergenzen achten, die auf eine nachlassende Überzeugung hinweisen.

• Keine Korrelation (Modulo von r < 0,5)

Beispiel: AUDUSD und USDJPY, r = 0,10

Interpretation: Die Entwicklung des AUDUSD hat so gut wie keine Vorhersagekraft für den USDJPY und vice versa. Diese „unabhängigen“ Paare sind ideale Diversifizierungskandidaten, da sie die Volatilität des Portfolios glätten, ohne eine versteckte Richtungsabhängigkeit zu verursachen.

Abb. 2. Dashboard

Abbildung 2 zeigt die Schnittstelle, die wir aufbauen wollen: eine Tabelle mit Korrelationswerten, bezeichnet mit „x“, die von -1 bis +1 reichen.

MQL5 Code Zerlegung

Wir beginnen, wie bei der MQL5-Entwicklung üblich, mit der Definition der grundlegenden Eigenschaften unseres Programms durch anfängliche Direktiven und die Einbeziehung notwendiger Bibliotheken. Diese Zeilen enthalten standardmäßige #property-Direktiven zur Identifizierung und Versionskontrolle und liefern wichtige Metadaten, die im MetaTrader 5-Terminal sichtbar sind.

//+------------------------------------------------------------------+
//|                                         Correlation Dashboard.mq5|
//|                                   Copyright 2025, MetaQuotes Ltd.|
//|                           https://www.mql5.com/en/users/lynnchris|
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/en/users/lynnchris"
#property version   "1.0"
#property strict

Ein entscheidendes Element ist hier #property strict, das strenge Kompilierungsregeln vorschreibt. Diese Praxis ist sehr empfehlenswert, da sie dazu beiträgt, potenzielle Kodierungsfehler frühzeitig im Entwicklungsprozess zu erkennen, was zu einem robusteren und zuverlässigeren Code führt. Im Anschluss an diese Direktiven wird die Bibliothek <Trade.mqh> eingebunden:

#include <Trade\Trade.mqh>

Dieser EA konzentriert sich zwar auf die Analyse und nicht auf den automatisierten Handel, aber die Einbindung dieser Bibliothek ermöglicht den Zugriff auf eine umfassende Reihe von Funktionen und Klassen, die für das Handelsmanagement relevant sind, und hält Optionen für zukünftige Erweiterungen oder die Integration in ein größeres Handelssystem offen.

Bevor wir Korrelationen effektiv berechnen und interpretieren können, benötigen wir einige grundlegende Bausteine. An dieser Stelle kommen unsere Nutzenfunktionen ins Spiel. Die Funktion AverageArray ist ein notwendiges Werkzeug zur Berechnung des Mittelwerts eines Datensatzes, ein Schritt, der in unserer Korrelationsformel erforderlich ist.

//+------------------------------------------------------------------+
//| Utility: average of an array                                     |
//+------------------------------------------------------------------+
double AverageArray(const double &arr[])
  {
   int sz = ArraySize(arr);
   if(sz == 0)
      return(0);
   double sum = 0;
   for(int i = 0; i < sz; i++)
      sum += arr[i];
   return(sum / sz);
  }

Die Funktion InterpretCorrelation geht über die reinen Zahlen hinaus und wandelt den berechneten Korrelationskoeffizienten in eine intuitivere Beschreibung um, indem sie die Stärke und Richtung der Beziehung mit Begriffen wie „stark positiv“ oder „schwache oder keine Korrelation“ auf der Grundlage von vordefinierten Schwellenwerten kategorisiert.

//+------------------------------------------------------------------+
//| Interpret raw correlation                                        |
//+------------------------------------------------------------------+
string InterpretCorrelation(double r)
  {
   if(r >=  0.8)
      return("strong positive correlation");
   if(r >=  0.5)
      return("moderate positive correlation");
   if(r >   -0.5)
      return("weak or no correlation");
   if(r >   -0.8)
      return("moderate negative correlation");
   return("strong negative correlation");
  }

Aufbauend auf dieser Interpretation bietet die Funktion RecommendAction praktische Kommentare und potenzielle Handelsimplikationen auf der Grundlage der beobachteten Korrelation zwischen zwei spezifischen Instrumenten, die aus der statistischen Analyse abgeleitete handlungsrelevante Erkenntnisse liefern.

//+------------------------------------------------------------------+
//| Recommend trading action based on r                              |
//+------------------------------------------------------------------+
string RecommendAction(double r, const string s1, const string s2)
  {
   if(r >=  0.8)
      return("They move almost in lock-step. Avoid opposite positions; use one as hedge.");
   if(r >=  0.5)
      return("Tendency to move together. Be cautious opening offset trades—seek confirmation.");
   if(r >   -0.5)
      return("Little to no relation: ideal for diversification.");
   if(r >   -0.8)
      return("Often move in opposition. Consider small inter-market spreads.");
   return("Very strong inverse relationship—candidate for statistical arbitrage.");
  }

Um das Correlation Dashboard an verschiedene Handelspräferenzen und analytische Bedürfnisse anzupassen, stellen wir eine Reihe von Eingabeparametern zur Verfügung, die der Nutzer über das Eigenschaftsfenster des EAs konfigurieren kann.

//+------------------------------------------------------------------+
//| Inputs                                                           |
//+------------------------------------------------------------------+
input string    InstrumentsList      = "EURUSD,GBPUSD,USDJPY,USDCHF,AUDUSD,NZDUSD,XAUUSD";
input ENUM_TIMEFRAMES TimeFrame      = PERIOD_H1;
input int       LookbackBars         = 100;    // bars for correlation
input double    AlertThreshold       = 0.8;    // threshold for alerts
input int       UpdateSeconds        = 5;      // timer interval

// Notifications
input bool      UsePushNotifications = true;
input bool      UseEmailAlerts       = false;

Zunächst definiert der Nutzer das Universum der zu analysierenden Vermögenswerte über die Instrumentenliste, indem er eine einfache, durch Kommata getrennte Zeichenfolge angibt. Sie wählen dann den Zeitrahmen für die Analyse aus und bestimmen die Granularität der verwendeten historischen Daten. LookbackBars ermöglicht dem Nutzer, die Länge des historischen Zeitraums zu bestimmen, der für die Korrelationsberechnung berücksichtigt wird. Mit dem Parameter AlertThreshold kann der Nutzer das Signifikanzniveau der Korrelation festlegen, das eine Benachrichtigung auslösen soll. UpdateSeconds schließlich legt die Häufigkeit fest, mit der der EA das Dashboard neu berechnet und aktualisiert, während UsePushNotifications und UseEmailAlerts die bevorzugten Methoden zum Erhalt von Warnmeldungen steuern.

Um sicherzustellen, dass wichtige Daten in verschiedenen Teilen des EA zugänglich sind, deklarieren wir einige globale Variablen.

//+------------------------------------------------------------------+
//| Globals                                                          |
//+------------------------------------------------------------------+
string Instruments[];
double CorrArray[];
int    InstrumentCount;

Das Array Instruments speichert die einzelnen Symbolnamen, nachdem sie aus der Eingabeliste des Nutzers geparst wurden. Das CorrArray ist ein spezielles Array zur Speicherung der berechneten paarweisen Korrelationskoeffizienten, das so organisiert ist, dass ein einfacher Zugriff auf die Korrelation zwischen zwei beliebigen Instrumenten möglich ist. Eine einfache Ganzzahl, InstrumentCount, zeigt an, wie viele Symbole gerade analysiert werden.

Wenn der Expert Advisor an einen Chart angehängt wird, wird als erstes die Funktion OnInit ausgeführt, die die notwendigen Komponenten für den Betrieb einrichtet. Zunächst wird InstrumentsList geparst, um das Array Instruments aufzufüllen, und es wird bestätigt, dass mindestens zwei Symbole angegeben wurden, da die Korrelation ein Paar erfordert.

//+------------------------------------------------------------------+
//| Expert initialization                                            |
//+------------------------------------------------------------------+
int OnInit()
  {
// parse & select instruments
   InstrumentCount = StringSplit(InstrumentsList, ',', Instruments);
   if(InstrumentCount < 2)
     {
      Print("Error: need at least two symbols.");
      return(INIT_FAILED);
     }
   for(int i = 0; i < InstrumentCount; i++)
      SymbolSelect(Instruments[i], true);

Es stellt dann sicher, dass MetaTrader für alle angegebenen Symbole mit SymbolSelect Daten zur Verfügung hat. Das CorrArray wird dann entsprechend dimensioniert, um alle paarweisen Korrelationen zu speichern.

// allocate storage
   ArrayResize(CorrArray, InstrumentCount * InstrumentCount);

Ein wichtiger Schritt ist hier der Aufruf von DrawDashboard(), der die erste visuelle Darstellung der Korrelationsmatrix im Chart wiedergibt.

// draw dashboard & start timer
   DrawDashboard();

Um sicherzustellen, dass das Dashboard dynamisch bleibt, wird EventSetTimer verwendet, um regelmäßige Aufrufe durch die Funktion OnTimer zu planen, die den Aktualisierungszyklus einleitet.

   EventSetTimer(UpdateSeconds);
   return(INIT_SUCCEEDED);
  }

Wenn einer der Initialisierungsschritte fehlschlägt (z. B. wenn weniger als zwei Symbole bereitgestellt werden), gibt OnInit INIT_FAILED zurück und verhindert damit die Ausführung des EA.

Wenn der EA nicht mehr benötigt wird und aus dem Chart entfernt oder das Terminal geschlossen wird, wird die Funktion OnDeinit ausgeführt, um die notwendigen Aufräumarbeiten durchzuführen.

//+------------------------------------------------------------------+
//| Expert deinitialization                                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   EventKillTimer();
   ClearObjects();
  }

Seine Hauptaufgaben bestehen darin, den periodischen Timer mit EventKillTimer() zu stoppen, um die weitere Ausführung der Aktualisierungslogik zu verhindern, und alle vom EA erstellten grafischen Objekte mit ClearObjects() aus dem Chart zu entfernen, um das Chart in einem sauberen Zustand zu hinterlassen.

Die Funktion OnTimer dient als Motor für das dynamische Verhalten des EA und wird automatisch in dem vom Nutzer angegebenen Intervall ausgelöst. Bei der Ausführung ruft er zunächst UpdateCorrelations() auf, um alle Korrelationsberechnungen mit den neuesten Daten zu aktualisieren.

//+------------------------------------------------------------------+
//| Timer: update, interpret, display, alert                         |
//+------------------------------------------------------------------+
void OnTimer()
  {
   UpdateCorrelations();

Anschließend wird jedes einzelne Instrumentenpaar durchlaufen, die Korrelation ermittelt und mit Hilfe der Utility-Funktionen ein interpretierender Text und Handelsempfehlungen generiert, die dann auf der Registerkarte Experten protokolliert werden.

// interpret & advise for each unique pair
   for(int i = 0; i < InstrumentCount; i++)
      for(int j = i + 1; j < InstrumentCount; j++)
        {
         double r    = CorrArray[i * InstrumentCount + j];
         string cat  = InterpretCorrelation(r);
         string tip  = RecommendAction(r, Instruments[i], Instruments[j]);
         PrintFormat(
            "%s vs %s \xBB r=%.2f: %s; Advice: %s",
            Instruments[i], Instruments[j],
            r, cat, tip
         );
        }

Nach der Verarbeitung der Daten wird RefreshValues() aufgerufen, um das visuelle Dashboard im Chart zu aktualisieren, wobei die neuen Korrelationskoeffizienten angezeigt und die Farbkodierung angepasst werden.

RefreshValues();

Schließlich wird durch den Aufruf von CheckAlerts() geprüft, ob Korrelationen den vordefinierten AlertThreshold überschritten haben, und wenn dies der Fall ist, wird der Benachrichtigungsprozess eingeleitet.

 CheckAlerts();
}

Die analytische Kernaufgabe wird innerhalb der Korrelationsberechnungsfunktionen durchgeführt. UpdateCorrelations() fungiert als Manager, indem es alle möglichen Paare von Instrumenten durchläuft und CalcCorrelation für jedes Paar aufruft, um den Korrelationskoeffizienten zu erhalten, der dann im CorrArray gespeichert wird.

//+------------------------------------------------------------------+
//| Compute pairwise correlations                                    |
//+------------------------------------------------------------------+
void UpdateCorrelations()
  {
   for(int i = 0; i < InstrumentCount; i++)
      for(int j = 0; j < InstrumentCount; j++)
         CorrArray[i * InstrumentCount + j] =
            CalcCorrelation(Instruments[i], Instruments[j]);
  }

Die Funktion CalcCorrelation(const string s1, const string s2) ist die Funktion, die die statistischen Berechnungen durchführt. Es ruft historische Schlusskursdaten für die angegebenen LookbackBars für beide Instrumente mit CopyClose ab.

//+------------------------------------------------------------------+
//| Pearson correlation                                              |
//+------------------------------------------------------------------+
double CalcCorrelation(const string s1, const string s2)
  {
   double a1[], a2[];
   if(CopyClose(s1, TimeFrame, 0, LookbackBars, a1) < LookbackBars ||
      CopyClose(s2, TimeFrame, 0, LookbackBars, a2) < LookbackBars)
      return(0);

Um ein relevantes Maß für Finanzdaten zu gewährleisten, wird die prozentuale Preisänderung zwischen aufeinanderfolgenden Balken berechnet.

int n = LookbackBars - 1;
double r1[], r2[];
ArrayResize(r1, n);
ArrayResize(r2, n);

for(int k = 1; k < LookbackBars; k++)
  {
   r1[k-1] = (a1[k] - a1[k-1]) / a1[k-1];
   r2[k-1] = (a2[k] - a2[k-1]) / a2[k-1];
  }

Anhand dieser normalisierten Preisänderungen wird der Pearson-Korrelationskoeffizient berechnet, der die lineare Beziehung zwischen den beiden Zeitreihen quantifiziert.

 double m1 = AverageArray(r1), m2 = AverageArray(r2);
 double num = 0, d1 = 0, d2 = 0;
 for(int k = 0; k < n; k++)
   {
    double da = r1[k] - m1;
    double db = r2[k] - m2;
    num += da * db;
    d1  += da * da;
    d2  += db * db;
   }
 return (d1 > 0 && d2 > 0) ? num / MathSqrt(d1 * d2) : 0;
}

Hier gibt es eine Prüfung, um Fälle zu behandeln, in denen es keine Preisschwankungen gibt, um eine Division durch Null zu vermeiden.

Das visuelle Dashboard im Chart wird über eine Reihe von Funktionen verwaltet. DrawDashboard() ist für den anfänglichen Aufbau des grafischen Layouts während der Initialisierung verantwortlich und erstellt die Matrixstruktur mit Beschriftungen für Symbole und Platzhalterbereichen für die Korrelationswerte.

//+------------------------------------------------------------------+
//| Draw static dashboard                                            |
//+------------------------------------------------------------------+
void DrawDashboard()
  {
   ClearObjects();
   const int x0 = 20, y0 = 40, dx = 100, dy = 25;

   CreateLabel("hdr", x0, y0-30, "Correlation Dashboard", clrWhite, 14);

// column headers
   for(int j = 0; j < InstrumentCount; j++)
      CreateLabel(
         StringFormat("col_%d", j),
         x0 + (j+1)*dx, y0,
         Instruments[j], clrYellow, 10
      );

// row headers & cells
   for(int i = 0; i < InstrumentCount; i++)
     {
      CreateLabel(
         StringFormat("row_%d", i),
         x0, y0 + (i+1)*dy,
         Instruments[i], clrYellow, 10
      );
      for(int j = 0; j < InstrumentCount; j++)
        {
         string rect = StringFormat("r_%d_%d", i, j);
         ObjectCreate(0, rect, OBJ_RECTANGLE_LABEL, 0, 0, 0);
         ObjectSetInteger(0, rect, OBJPROP_XDISTANCE, x0 + (j+1)*dx - 5);
         ObjectSetInteger(0, rect, OBJPROP_YDISTANCE, y0 + (i+1)*dy - 12);
         ObjectSetInteger(0, rect, OBJPROP_XSIZE, dx);
         ObjectSetInteger(0, rect, OBJPROP_YSIZE, dy);

         CreateLabel(
            StringFormat("val_%d_%d", i, j),
            x0 + (j+1)*dx, y0 + (i+1)*dy,
            "--", clrWhite, 9
         );
        }
     }
  }

ClearObjects() ist eine Utility-Funktion, die alle vom EA erstellten Objekte effizient aus dem Chart entfernt. Sie wird während der Deinitialisierung und möglicherweise vor dem Neuzeichnen verwendet.

//+------------------------------------------------------------------+
//| Clear all chart objects                                          |
//+------------------------------------------------------------------+
void ClearObjects()
  {
   for(int i = ObjectsTotal(0)-1; i >= 0; i--)
      ObjectDelete(0, ObjectName(0, i));
  }

RefreshValues() ist die Funktion, die in regelmäßigen Abständen von OnTimer aufgerufen wird, um die visuelle Anzeige zu aktualisieren. Es ruft die neuesten Korrelationswerte ab und passt die Hintergrund- und Textfarben der Dashboard-Zellen dynamisch an. So entsteht eine Heatmap-Visualisierung, mit der sich starke positive und negative Korrelationen schnell erkennen lassen.

//+------------------------------------------------------------------+
//| Refresh heat-map values & colors                                 |
//+------------------------------------------------------------------+
void RefreshValues()
  {
   for(int i = 0; i < InstrumentCount; i++)
      for(int j = 0; j < InstrumentCount; j++)
        {
         double v = CorrArray[i * InstrumentCount + j];
         color bg = (v >  0.8 ? clrGreen :
                     v >  0.5 ? clrLightGreen :
                     v < -0.5 ? clrRed   : clrLightCoral);
         color fg = (v >= 0  ? clrLime : clrRed);

         string rect = StringFormat("r_%d_%d", i, j);
         if(ObjectFind(0, rect) != -1)
            ObjectSetInteger(0, rect, OBJPROP_COLOR, bg);

         string lbl = StringFormat("val_%d_%d", i, j);
         if(ObjectFind(0, lbl) != -1)
           {
            ObjectSetString(0, lbl, OBJPROP_TEXT, DoubleToString(v, 2));
            ObjectSetInteger(0, lbl, OBJPROP_COLOR, fg);
           }
        }
  }

Um den Nutzer über signifikante Veränderungen in den Marktbeziehungen auf dem Laufenden zu halten, ist in der Funktion CheckAlerts ein Alarmierungsmechanismus implementiert.

//+------------------------------------------------------------------+
//| Alert on threshold & notify                                      |
//+------------------------------------------------------------------+
void CheckAlerts()
  {
   for(int i = 1; i < InstrumentCount; i++)
     {
      double v = CorrArray[i]; // Potential issue here, likely intended CorrArray[0 * InstrumentCount + i]
      if(v >= AlertThreshold) // Only checks for positive correlation >= threshold
        {
         string msg = StringFormat(
                         "High correlation: %s vs %s = %.2f",
                         Instruments[0], Instruments[i], v
                      );
         Alert(msg);
         Print(msg);
         if(UsePushNotifications)
            SendNotification(msg);
         if(UseEmailAlerts)
            SendMail("Correlation Alert", msg);
        }
     }
  }

Diese Funktion überwacht insbesondere die Korrelation zwischen dem ersten Symbol in der Liste des Nutzers und allen anderen Instrumenten. Wenn die Korrelation (in dieser Implementierung über dem positiven Schwellenwert, obwohl sie leicht angepasst werden kann, um starke negative Korrelationen durch Überprüfung des absoluten Wertes einzubeziehen) den AlertThreshold erreicht oder überschreitet, wird eine Benachrichtigung ausgelöst. Dies beinhaltet die Generierung einer klaren Nachricht, die das Paar und seine Korrelation detailliert beschreibt, die Anzeige einer Standardwarnung von MetaTrader 5, den Ausdruck der Nachricht auf der Registerkarte „Experten“ und optional den Versand von Push-Benachrichtigungen oder E-Mails je nach Konfiguration des Nutzers.

Anmerkung: Wie im Codekommentar hervorgehoben, scheint es in dieser Funktion ein potenzielles Indizierungsproblem in CorrArray[i] zu geben, das wahrscheinlich auf die Korrelation zwischen Instruments[0] und Instruments[i] zugreifen will. Außerdem gibt es derzeit nur bei positiven Korrelationen, die den Schwellenwert überschreiten, eine Warnmeldung aus; bei starken negativen Korrelationen müsste der absolute Wert überprüft werden.

Ergebnisse

Beim Einsatz auf Live-Daten hat der EA das Dashboard sofort dargestellt. Er begann, aktuelle Korrelationswerte in grüner Farbe für positive Beziehungen und in roter Farbe für inverse Beziehungen anzuzeigen. Die Anzeige wird in jedem eingestellten Intervall aktualisiert. Auf der Registerkarte Experten wurde jeder Koeffizient erfasst. Sie lieferte eine knappe Interpretation der einzelnen Werte. Auf diese Weise können Sie sowohl die reinen Zahlen als auch deren praktische Bedeutung überprüfen, ohne etwas zu verpassen.

2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      EURUSD vs USDJPY → r=-0.79: moderate negative correlation; Advice: Often move in opposition. Consider small inter-market spreads.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      EURUSD vs USDCHF → r=-0.80: moderate negative correlation; Advice: Often move in opposition. Consider small inter-market spreads.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      EURUSD vs AUDUSD → r=0.48: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      EURUSD vs NZDUSD → r=0.57: moderate positive correlation; Advice: Tendency to move together. Be cautious opening offset trades—seek confirmation.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      EURUSD vs XAUUSD → r=0.11: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      GBPUSD vs USDJPY → r=-0.71: moderate negative correlation; Advice: Often move in opposition. Consider small inter-market spreads.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      GBPUSD vs USDCHF → r=-0.63: moderate negative correlation; Advice: Often move in opposition. Consider small inter-market spreads.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      GBPUSD vs AUDUSD → r=0.54: moderate positive correlation; Advice: Tendency to move together. Be cautious opening offset trades—seek confirmation.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      GBPUSD vs NZDUSD → r=0.63: moderate positive correlation; Advice: Tendency to move together. Be cautious opening offset trades—seek confirmation.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      GBPUSD vs XAUUSD → r=0.11: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDJPY vs USDCHF → r=0.75: moderate positive correlation; Advice: Tendency to move together. Be cautious opening offset trades—seek confirmation.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDJPY vs AUDUSD → r=-0.33: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDJPY vs NZDUSD → r=-0.47: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDJPY vs XAUUSD → r=-0.04: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDCHF vs AUDUSD → r=-0.24: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDCHF vs NZDUSD → r=-0.32: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDCHF vs XAUUSD → r=0.05: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      AUDUSD vs NZDUSD → r=0.87: strong positive correlation; Advice: They move almost in lock-step. Avoid opposite positions; use one as hedge.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      AUDUSD vs XAUUSD → r=0.08: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      NZDUSD vs XAUUSD → r=0.11: weak or no correlation; Advice: Little to no relation: ideal for diversification.

Die obigen Informationen stammen aus dem Protokoll der Registerkarte Experten, in dem jede neu entdeckte Korrelation aufgezeichnet wird. Ich habe die stärksten Beziehungen hervorgehoben, die mit r ≤ -0,8 (stark negativ) und r ≥ +0,8 (stark positiv). Nachfolgend finden Sie das Chart auf dem Dashboard als visuelle Referenz.

Abb. 3. Korrelationstafel

NZDUSD und AUDUSD weisen eine starke positive Korrelation auf, d. h. sie bewegen sich parallel zu nahezu identischen Kursen. Im Folgenden vergleichen wir die Echtzeit-Kursbewegungen nebeneinander, um zu bestätigen, dass die Korrelationsanzeige des Dashboards das Marktgeschehen genau wiedergibt.

Abb. 4. Starke positive Korrelation

Das obige Diagramm veranschaulicht eine starke positive Korrelation zwischen diesen Paaren, eine direkte Beziehung, bei der sie fast gleichzeitig verkaufen und kaufen. Vom 6. bis 7. Mai bewegten sich beide Paare zunächst rückläufig, bevor sie in einen Aufwärtstrend übergingen. Unten habe ich eine mäßige negative Korrelation dargestellt: Sie können erkennen, dass sich inverse Strukturen bilden, bei denen ein Paar verkauft, während das andere kauft, und umgekehrt, meistens.

Abb. 5. Mäßig negative Korrelation

Schlussfolgerung

Der Correlation Dashboard EA liefert wertvolle Einblicke in das Preisgeschehen zwischen den Paaren, ohne dass Sie die Charts wechseln müssen. Durch die Darstellung der Beziehungen in Echtzeit können Sie Marktveränderungen bei verschiedenen Instrumenten vorhersehen und fundiertere Handelsentscheidungen treffen. Das On-Chart-Panel und die Protokolle auf der Registerkarte „Experten“ mögen einfach aussehen, aber sie stellen die Kernfunktionalität klar dar: ein sich selbst aktualisierendes Dashboard mit farbkodierten Koeffizienten und interpretierenden Meldungen. Sie können die Nutzeroberfläche leicht umgestalten oder erweitern, aber die wesentlichen analytischen Daten sind bereits vorhanden. Sie sind herzlich eingeladen, sich mit Fragen oder Vorschlägen an uns zu wenden!

Datum	Name des Tools	Beschreibung	Version	Aktualisierungen	Hinweis
01/10/24	Chart Projector	Skript zur Überlagerung der Kursentwicklung des Vortages mit einem Ghost-Effekt.	1.0	Erste Veröffentlichung	Tool Nummer 1
18/11/24	Analytical Comment	Er liefert Informationen zum Vortag in Tabellenform und nimmt die zukünftige Marktentwicklung vorweg.	1.0	Erste Veröffentlichung	Tool Nummer 2
27/11/24	Analytics Master	Reguläre Aktualisierung der Marktmetriken alle zwei Stunden.	1.01	Zweite Veröffentlichung	Tool Nummer 3
02/12/24	Analytics Forecaster	Reguläre Aktualisierung der Marktmetriken alle zwei Stunden mit Telegram-Integration.	1.1	Dritte Ausgabe	Tool Nummer 4
09/12/24	Volatility Navigator	Der EA analysiert die Marktbedingungen anhand der Indikatoren Bollinger Bands, RSI und ATR.	1.0	Erste Veröffentlichung	Tool Nummer 5
19/12/24	Mean Reversion Signal Reaper	Analysiert den Markt anhand der Strategie „Umkehr zur Mitte“ und liefert Signale.	1.0	Erste Veröffentlichung	Tool Nummer 6
9/01/25	Signal Pulse	Analysator für mehrere Zeitrahmen.	1.0	Erste Veröffentlichung	Tool Nummer 7
17/01/25	Metrics Board	Bedienfeld mit Taste für die Analyse.	1.0	Erste Veröffentlichung	Tool Nummer 8
21/01/25	External Flow	Analytik durch externe Bibliotheken.	1.0	Erste Veröffentlichung	Tool Nummer 9
27/01/25	VWAP	Volumengewichteter Durchschnittspreis	1.3	Erste Veröffentlichung	Tool Nummer 10
02/02/25	Heikin Ashi	Trendglättung und Identifizierung von Umkehrsignalen	1.0	Erste Veröffentlichung	Tool Nummer 11
04/02/25	FibVWAP	Signalerzeugung durch Python-Analyse	1.0	Erste Veröffentlichung	Tool Nummer 12
14/02/25	RSI DIVERGENCE	Kursentwicklung versus RSI-Divergenzen	1.0	Erste Veröffentlichung	Tool Nummer 13
17/02/25	Parabolic Stop and Reverse (PSAR)	Automatisierung der PSAR-Strategie	1.0	Erste Veröffentlichung	Tool Nummer 14
20/02/25	Quarters Drawer Script	Einzeichnen der Ebenen der Viertel auf dem Chart	1.0	Erste Veröffentlichung	Tool Nummer 15
27/02/25	Intrusion Detector	Erkennen und warnen, wenn der Preis ein Viertel-Niveau erreicht	1.0	Erste Veröffentlichung	Tool Nummer 16
27/02/25	TrendLoom Tool	Analysepanel für mehrere Zeitrahmen	1.0	Erste Veröffentlichung	Tool Nummer 17
11/03/25	Quarters Board	Bedienfeld mit Tasten zum Aktivieren oder Deaktivieren der Viertel-Ebenen	1.0	Erste Veröffentlichung	Tool Nummer 18
26/03/25	ZigZag Analyzer	Zeichnen von Trendlinien mit dem ZigZag-Indikator	1.0	Erste Veröffentlichung	Tool Nummer 19
10/04/25	Correlation Pathfinder	Plotten von Währungskorrelationen mit Python-Bibliotheken.	1.0	Erste Veröffentlichung	Tool Nummer 20
23/04/25	Market Structure Flip Detector Tool	Erkennung von Marktstrukturschwankungen	1.0	Erste Veröffentlichung	Tool Nummer 21
08/05/25	Correlation Dashboard	Beziehung zwischen verschiedenen Paaren	1.0	Erste Veröffentlichung	Tool Nummer 22