Saisonalitätsindikator nach Stunden, Wochentagen und Tagen des Monats

Kurse spielen eine Melodie, die sich an bestimmten Tagen des Monats, Wochentagen oder sogar Stunden des Tages wiederholt. Diese wiederkehrenden Rhythmen, oder saisonalen Muster, können einem Trader Hinweise darauf geben, wann der Markt wahrscheinlich steigen und wann er wahrscheinlich fallen wird. Saisonalität an Finanzmärkten ist nicht nur ein kurioses Phänomen, sondern ein Werkzeug, das hilft, vorhersehbare Momente im Kurschaos zu identifizieren. Haben Sie zum Beispiel bemerkt, dass einige Währungspaare oft montags steigen oder am Monatsende fallen? Das ist Saisonalität, und ihre Untersuchung kann Tradern einen Vorteil verschaffen.

In diesem Leitfaden erstellen wir einen Saisonalitätsindikator in MQL5 für die MetaTrader 5-Plattform. Unser Indikator analysiert historische Kursdaten, um die durchschnittliche Rendite für Tage des Monats (1. bis 31.), Wochentage (Montag bis Sonntag) oder Stunden des Tages (0 bis 23) zu ermitteln. Die Ergebnisse werden als Histogramm in einem separaten Chartfenster angezeigt, wobei eine Prognoselinie die Saisonalitätswerte verbindet und Punkte die erwarteten Werte auf den folgenden Bars hervorheben. Zusätzlich zeigt der Indikator Textstatistiken mit Prognosen sowie den besten und schlechtesten Zeiträumen an. Wir führen Sie Schritt für Schritt durch den Entwicklungsprozess und erklären jeden Teil des Codes, damit Sie den Indikator nicht nur verwenden, sondern auch an Ihre eigenen Ideen anpassen können. Dieser Leitfaden führt Sie sowohl durch die Programmierung als auch durch die Finanzanalyse, wobei der Code zur Brücke zwischen Daten und Handelsentscheidungen wird.

Warum Saisonalität untersuchen?

Saisonalität ist wie der verborgene Puls des Marktes. Sie entsteht durch viele Faktoren: das Verhalten von Tradern, wirtschaftliche Ereignisse und sogar die menschliche Psychologie. Zum Beispiel können große Fonds am Monatsende Positionen schließen, was zu vorhersehbaren Kursbewegungen führt. Oder zu bestimmten Tageszeiten nimmt die Marktaktivität aufgrund der Eröffnung der Handelssitzungen in London oder New York zu. Unser Indikator hilft Ihnen dabei, diese Muster zu erkennen, indem er chaotische Daten in klare Charts und Statistiken umwandelt. Dies ist keine Magie, sondern Datenanalyse, die zugunsten des Traders arbeitet.

Der Indikator, den wir erstellen werden, wird vielseitig einsetzbar sein. Er ermöglicht es Tradern, die Art der Saisonalität auszuwählen, die Anzahl der zu analysierenden Bars festzulegen, Renditen als Prozentsatz oder absoluten Wert anzuzeigen und die Prognose im Chart zu aktivieren oder zu deaktivieren. Flexibilität ist der Schlüssel dazu, den Indikator zu einem nützlichen Werkzeug für verschiedene Märkte und Zeitrahmen zu machen, sei es das tägliche EURUSD-Chart oder das stündliche Gold-Chart.

Die Struktur des Indikators definieren

Die Erstellung eines Indikators beginnt mit dem Verständnis, wie er aussehen und funktionieren soll. Wir möchten, dass er in einem separaten Fenster unterhalb des Charts angezeigt wird, um den Hauptbereich nicht zu überladen. Wir verwenden drei Elemente zur Visualisierung: ein Histogramm, das die durchschnittliche Rendite für jede Periode zeigt, eine Prognoselinie, die die Saisonalitätswerte und die Prognosedaten verbindet, sowie Prognosepunkte, die die erwarteten Werte auf den nächsten zwei Bars hervorheben. Jedes Element wird mit einem Datenpuffer verknüpft – einem Array, das die zu zeichnenden Werte speichert. Wir benötigen außerdem globale Variablen zum Speichern von Saisonalitätsdaten und Bezeichnungen der Perioden sowie Eingabeparameter, damit der Trader den Indikator anpassen kann.

//+------------------------------------------------------------------+
//|                                         SeasonalityIndicator.mq5 |
//|                                  Copyright 2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 3
#property indicator_plots   3

//--- plot Seasonality
#property indicator_label1  "Seasonality"
#property indicator_type1   DRAW_HISTOGRAM
#property indicator_color1  clrDodgerBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  2

//--- plot Forecast Line
#property indicator_label2  "Forecast"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrRed
#property indicator_style2  STYLE_DASH
#property indicator_width2  2

//--- plot Forecast Points
#property indicator_label3  "Forecast Points"
#property indicator_type3   DRAW_ARROW
#property indicator_color3  clrOrange
#property indicator_width3  3

In diesem Code legen wir grundlegende Informationen über den Indikator fest: Copyright, Link zur MetaQuotes-Website und Version. Die Anweisung #property indicator_separate_window legt fest, dass sich der Indikator in einem separaten Fenster befindet. Wir definieren drei Puffer und drei Plots. Das DRAW_HISTOGRAM-Histogramm ist blau gefärbt, die DRAW_LINE-Prognoselinie ist rot gefärbt und die DRAW_ARROW-Prognosepunkte sind orange gefärbt mit einer Breite von drei Pixeln. Diese Einstellungen definieren den visuellen Stil, der den Indikator klar und attraktiv macht.

Eingabeparameter einrichten

Um den Indikator flexibel zu gestalten, fügen wir Eingabeparameter hinzu, die der Trader im Einstellungsfenster von MetaTrader 5 ändern kann. Der Parameter zur Auswahl des Saisonalitätstyps ermöglicht es uns, Tage des Monats, Wochentage oder Stunden des Tages zu analysieren. Die Anzahl der zu analysierenden Bars bestimmt, wie weit wir in die Vergangenheit zurückblicken können. Es ist möglich, Renditen als Prozentsatz oder als absoluten Wert anzuzeigen sowie nur positive Saisonalitätswerte darzustellen. Die Option, die Prognose im Chart zu aktivieren und die Farben der Linie sowie der Prognosepunkte anzupassen, macht den Indikator noch flexibler.

//--- Input parameters
enum ENUM_SEASONALITY_TYPE
{
   SEASONALITY_DAYS_OF_MONTH = 0,  // Days of the month (1-31)
   SEASONALITY_DAYS_OF_WEEK = 1,   // Days of the week (Mon-Sun)
   SEASONALITY_HOURS = 2           // Hours (0-23)
};

input ENUM_SEASONALITY_TYPE SeasonalityType = SEASONALITY_DAYS_OF_MONTH; // Seasonality type
input int BarsToAnalyze = 1000;                                          // Number of bars to analyze 
input bool ShowPercentage = true;                                        // Show as a percentage
input bool ShowPositiveOnly = false;                                     // Show only positive values
input bool ShowForecastOnChart = true;                                   // Show forecast on chart
input color ForecastColor = clrRed;                                      // Forecast line color
input color ForecastPointsColor = clrOrange;                             // Color of forecast points

Die Enumeration ENUM_SEASONALITY_TYPE definiert drei Saisonalitätsoptionen. Standardmäßig ist die Analyse nach Tagen des Monats ausgewählt. Der Parameter BarsToAnalyze ist auf 1000 Bars eingestellt, was ungefähr vier Jahren an Daten in einem Tageschart entspricht. Die Option ShowPercentage ist standardmäßig aktiviert, um Renditen als Prozentsatz anzuzeigen, was intuitiver ist. Die Parameter ShowPositiveOnly und ShowForecastOnChart bieten zusätzliche Flexibilität, und die Farben können über die MetaTrader-Oberfläche geändert werden.

Puffer und Variablen definieren

Zum Speichern von Daten verwendet der Indikator drei Puffer: einen für das Histogramm, den zweiten für die Prognoselinie und den dritten für Prognosepunkte. Globale Variablen werden ebenfalls benötigt: ein Array zum Speichern der durchschnittlichen Rendite pro Periode, ein Array für Bezeichnungen der Perioden (zum Beispiel „Mon“ oder „1“) und eine Variable für die Anzahl der Perioden, die von der Art der Saisonalität abhängt (31 für Tage des Monats, 7 für Wochentage, 24 für Stunden).

//--- Indicator buffers
double SeasonalityBuffer[];
double ForecastLineBuffer[];
double ForecastPointsBuffer[];

//--- Global variables
double seasonality_data[];
string period_labels[];
int periods_count;

Die Puffer enthalten die darzustellenden Daten, und die Variablen seasonality_data und period_labels helfen beim Speichern und Anzeigen der Analyseergebnisse. Die Variable periods_count bestimmt, wie viele Perioden analysiert werden, und wird je nach Art der Saisonalität festgelegt.

Initialisierung des Indikators

Die Funktion OnInit wird beim Start des Indikators ausgeführt und ist für die Ersteinrichtung verantwortlich. Sie bindet die Puffer an die Indikator-Plots, legt den Pfeilstil für Prognosepunkte fest und setzt Farben aus Benutzerparametern. Je nach Saisonalitätstyp werden Beschriftungen für die Perioden erstellt und das Array zum Speichern der Saisonalitätsdaten mit Nullen initialisiert. Die Anzeigegenauigkeit wird angepasst, je nachdem, ob Prozentsätze oder absolute Werte ausgewählt sind.

int OnInit()
{
   SetIndexBuffer(0, SeasonalityBuffer, INDICATOR_DATA);
   SetIndexBuffer(1, ForecastLineBuffer, INDICATOR_DATA);
   SetIndexBuffer(2, ForecastPointsBuffer, INDICATOR_DATA);
   
   PlotIndexSetInteger(2, PLOT_ARROW, 159);
   
   PlotIndexSetInteger(1, PLOT_LINE_COLOR, ForecastColor);
   PlotIndexSetInteger(2, PLOT_LINE_COLOR, ForecastPointsColor);
   
   switch(SeasonalityType)
   {
      case SEASONALITY_DAYS_OF_MONTH:
         periods_count = 31;
         ArrayResize(period_labels, periods_count);
         for(int i = 0; i < periods_count; i++)
            period_labels[i] = IntegerToString(i + 1);
         IndicatorSetString(INDICATOR_SHORTNAME, "Seasonality by day of the month");
         break;
         
      case SEASONALITY_DAYS_OF_WEEK:
         periods_count = 7;
         ArrayResize(period_labels, periods_count);
         period_labels[0] = "Mon";
         period_labels[1] = "Tue";
         period_labels[2] = "Wed";
         period_labels[3] = "Thu";
         period_labels[4] = "Fri";
         period_labels[5] = "Sat";
         period_labels[6] = "Sun";
         IndicatorSetString(INDICATOR_SHORTNAME, "Seasonality by day of the week");
         break;
         
      case SEASONALITY_HOURS:
         periods_count = 24;
         ArrayResize(period_labels, periods_count);
         for(int i = 0; i < periods_count; i++)
            period_labels[i] = IntegerToString(i) + ":00";
         IndicatorSetString(INDICATOR_SHORTNAME, "Seasonality by hours");
         break;
   }
   
   ArrayResize(seasonality_data, periods_count);
   ArrayInitialize(seasonality_data, 0.0);
   
   IndicatorSetInteger(INDICATOR_DIGITS, ShowPercentage ? 2 : _Digits);
   
   return(INIT_SUCCEEDED);
}

Diese Funktion bildet die Grundlage für den Betrieb des Indikators. Zum Beispiel wird für Wochentage ein Array von Beschriftungen von „Mon“ bis „Sun“ (wie im Code definiert) erstellt und für Stunden von „0:00“ bis „23:00“. Der Indikatorname ändert sich, sodass der Trader sofort versteht, welche Art von Saisonalität ausgewählt ist. Dies macht den Indikator intuitiv.

Berechnung der Saisonalität

Die Hauptberechnungen werden in der Funktion OnCalculate durchgeführt. Sie analysiert historische Kursdaten, berechnet die durchschnittliche Rendite für jeden Zeitraum und füllt die Puffer für die Darstellung. Zuerst prüfen wir, ob genügend Bars im Chart vorhanden sind. Dann werden Hilfsarrays erstellt, um die Renditen zu summieren und die Bars in jedem Zeitraum zu zählen.

Für jede Bar wird die Rendite als Verhältnis der Differenz der Schlusskurse zum aktuellen Schlusskurs berechnet. Die Funktion GetPeriodIndex bestimmt, zu welchem Zeitraum die Bar gehört, und die Daten werden in Arrays geschrieben. Danach wird die durchschnittliche Rendite berechnet, die bei Bedarf in einen Prozentsatz umgewandelt oder bei negativen Werten auf null zurückgesetzt wird. Die Puffer werden mit Daten gefüllt, und eine separate Funktion für die Prognose wird aufgerufen.

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 < BarsToAnalyze + 1)
      return(0);

   ArrayInitialize(seasonality_data, 0.0);
   
   double period_returns[];
   int period_counts[];
   ArrayResize(period_returns, periods_count);
   ArrayResize(period_counts, periods_count);
   ArrayInitialize(period_returns, 0.0);
   ArrayInitialize(period_counts, 0);
   
   int start_pos = MathMax(0, rates_total - BarsToAnalyze - 1);
   
   for(int i = start_pos; i < rates_total - 1; i++)
   {
      double return_value = 0.0;
      if(close[i] != 0)
         return_value = (close[i+1] - close[i]) / close[i];
      
      int period_index = GetPeriodIndex(time[i]);
      
      if(period_index >= 0 && period_index < periods_count)
      {
         period_returns[period_index] += return_value;
         period_counts[period_index]++;
      }
   }
   
   for(int i = 0; i < periods_count; i++)
   {
      if(period_counts[i] > 0)
      {
         seasonality_data[i] = period_returns[i] / period_counts[i];
         if(ShowPercentage)
            seasonality_data[i] *= 100.0;
         if(ShowPositiveOnly && seasonality_data[i] < 0)
            seasonality_data[i] = 0.0;
      }
   }
   
   for(int i = 0; i < rates_total; i++)
   {
      int period_index = GetPeriodIndex(time[i]);
      if(period_index >= 0 && period_index < periods_count)
      {
         SeasonalityBuffer[i] = seasonality_data[period_index];
         ForecastLineBuffer[i] = seasonality_data[period_index];
      }
      else
      {
         SeasonalityBuffer[i] = 0.0;
         ForecastLineBuffer[i] = 0.0;
      }
      ForecastPointsBuffer[i] = EMPTY_VALUE;
   }
   
   if(ShowForecastOnChart)
      DrawForecastOnChart(rates_total, time);
   
   return(rates_total);
}

Dieser Code ist das Herzstück des Indikators. Er verwandelt unverarbeitete Kursdaten in aussagekräftige Muster. Stellen Sie sich vor, Sie analysieren den Tageschart eines Währungspaares. Für jeden Wochentag berechnet der Indikator, wie stark sich der Kurs verändert hat, und ermittelt den Durchschnittswert. Wenn Sie sehen, dass der Markt freitags durchschnittlich um 0,05 % fällt, könnte dies ein Signal für eine Handelsstrategie sein.

Definition des Zeitraums

Um zu verstehen, zu welchem Zeitraum jede Bar gehört, erstellen wir die Funktion GetPeriodIndex. Sie wandelt die Barzeit in einen Periodenindex um, abhängig von der Art der Saisonalität. Für Tage des Monats nimmt sie die Tagesnummer und subtrahiert eins, um einen Index von 0 bis 30 zu erhalten. Für Wochentage wandelt sie den Wochentagswert (wobei Sonntag 0 und Montag 1 ist) in eine Wochentagsreihenfolge um, bei der Montag 0 und Sonntag 6 ist. Für Stunden wird einfach der Stundenwert von 0 bis 23 zurückgegeben.

int GetPeriodIndex(datetime bar_time)
{
   MqlDateTime dt;
   TimeToStruct(bar_time, dt);
   
   switch(SeasonalityType)
   {
      case SEASONALITY_DAYS_OF_MONTH:
         return(dt.day - 1);
         
      case SEASONALITY_DAYS_OF_WEEK:
         return(dt.day_of_week == 0 ? 6 : dt.day_of_week - 1);
         
      case SEASONALITY_HOURS:
         return(dt.hour);
   }
   
   return(-1);
}

Diese Funktion ist wie ein Kompass, der dem Indikator hilft zu verstehen, welcher Kategorie die Bardaten zuzuordnen sind. Ohne sie wären wir nicht in der Lage, den Kurs einem bestimmten Tag oder einer bestimmten Stunde zuzuordnen.

Zeichnen der Prognose

Die Prognose macht den Indikator nicht nur analytisch, sondern auch praktisch nutzbar. Die Funktion DrawForecastOnChart zeichnet die erwarteten Saisonalitätswerte auf den letzten beiden Bars des Charts. Sie bestimmt die aktuelle Periode und die nächsten beiden Perioden mithilfe der Funktion GetNextPeriod. Saisonalitätswerte für diese Perioden werden in die Puffer für die Prognoselinie und den Punkt geschrieben. Damit die Prognoselinie glatt aussieht, wird der Wert der aktuellen Periode in den Puffer der vorletzten Bar geschrieben.

void DrawForecastOnChart(int rates_total, const datetime &time[])
{
   if(rates_total < 3)
      return;
   
   datetime current_time = time[rates_total - 1];
   int current_period = GetPeriodIndex(current_time);
   int next_period1 = GetNextPeriod(current_period);
   int next_period2 = GetNextPeriod(next_period1);
   
   int forecast_pos1 = rates_total - 2;
   int forecast_pos2 = rates_total - 1;
   
   if(next_period1 >= 0 && next_period1 < periods_count)
   {
      ForecastLineBuffer[forecast_pos1] = seasonality_data[next_period1];
      ForecastPointsBuffer[forecast_pos1] = seasonality_data[next_period1];
   }
   
   if(next_period2 >= 0 && next_period2 < periods_count)
   {
      ForecastLineBuffer[forecast_pos2] = seasonality_data[next_period2];
      ForecastPointsBuffer[forecast_pos2] = seasonality_data[next_period2];
   }
   
   if(rates_total >= 3)
   {
      int current_pos = rates_total - 3;
      int current_period_idx = GetPeriodIndex(time[current_pos]);
      
      if(current_period_idx >= 0 && current_period_idx < periods_count)
      {
         double current_value = seasonality_data[current_period_idx];
         double next_value = (next_period1 >= 0) ? seasonality_data[next_period1] : current_value;
         
         ForecastLineBuffer[current_pos] = current_value;
         if(forecast_pos1 < rates_total)
            ForecastLineBuffer[forecast_pos1] = next_value;
      }
   }
}

Eine Prognose ist wie ein Blick in die Zukunft: Der Indikator sagt Ihnen basierend auf historischen Daten, was zu erwarten ist. Wenn zum Beispiel Dienstage typischerweise +0,07 % Rendite bringen, zeigt der Indikator dies im Chart an und hilft dem Trader bei der Vorbereitung.

Berechnung der nächsten Periode

Die Funktion GetNextPeriod bestimmt, welche Periode auf die aktuelle folgt. Sie verwendet Modulo-Arithmetik, um einen zyklischen Übergang zu ermöglichen: Nach dem 31. Tag des Monats kommt der 1., nach Sonntag kommt Montag, nach 23:00 Uhr kommt 0:00 Uhr.

int GetNextPeriod(int current_period)
{
   if(current_period < 0)
      return(-1);
   
   switch(SeasonalityType)
   {
      case SEASONALITY_DAYS_OF_MONTH:
         return((current_period + 1) % 31);
         
      case SEASONALITY_DAYS_OF_WEEK:
         return((current_period + 1) % 7);
         
      case SEASONALITY_HOURS:
         return((current_period + 1)rate_total % 24);
   }
   
   return(-1);
}

Diese Funktion stellt sicher, dass die Prognose immer die korrekten zukünftigen Perioden betrachtet und die zyklische Zeitlogik beibehält. Sie fungiert als präziser Marktkalender und stellt sicher, dass sich der Indikator korrekt von einer Periode zur nächsten bewegt, sei es beim Wechsel der Tage des Monats, der Wochentage oder der Stunden. Stellen Sie sich den Markt wie eine riesige Uhr vor, bei der jeder Tick nicht nur die Zeit, sondern auch potenzielle Kursbewegungen zählt. Nach dem 31. Tag des Monats führt uns die Funktion reibungslos zum 1. Tag zurück, nach Sonntag geht es zum Montag und nach 23:00 Uhr auf 0:00 Uhr. Dieser zyklische Ansatz spiegelt die reale Zeitstruktur der Finanzmärkte wider und ermöglicht es dem Indikator, vorherzusagen, welche Perioden für einen Trader von Bedeutung sein könnten.

Anzeige der Statistik

Damit Trader die Analyseergebnisse sofort verstehen können, zeigt der Indikator detaillierte Statistiken direkt im Chart an. Die Funktion ShowStatistics erstellt eine Textnachricht, die – wie ein Erzähler – trockene Zahlen in eine anschauliche Geschichte über Marktmuster verwandelt.

Sie beginnt mit einem Titel, der sich je nach Art der gewählten Saisonalität ändert – sei es eine Analyse nach Kalendertag des Monats, Wochentag oder Stunde des Tages. Anschließend wird die Anzahl der analysierten Bars angegeben, was dem Trader eine Vorstellung von der Tiefe der historischen Daten gibt, die den Berechnungen zugrunde liegen. Als Nächstes wird die aus der Funktion GetForecast erhaltene Prognose hinzugefügt, die auf Basis historischer Trends vorhersagt, wie sich der Markt in den nächsten zwei Perioden entwickeln könnte. Danach untersucht die Funktion sorgfältig das Array seasonality_data und findet die Perioden mit den höchsten und niedrigsten Renditen. Diese Perioden werden als beste und schlechteste gekennzeichnet, und ihre Werte werden auf drei Dezimalstellen genau angezeigt, damit der Trader ihre Bedeutung einschätzen kann.

Die Nachricht schließt mit vollständigen Statistiken ab, wobei für jede Periode deren Bezeichnung – zum Beispiel „Mo“ oder „15“ – und die durchschnittliche Rendite angezeigt werden. Der Text erscheint in der oberen rechten Ecke des Charts als kompakte analytische Zusammenfassung der Marktrhythmen, wodurch diese verständlich und nützlich für Handelsentscheidungen werden.

Schlussfolgerung

Saisonalität an den Finanzmärkten ist kein mystisches Phänomen, sondern ein mathematisch belegtes Muster, das zu einem mächtigen Werkzeug im Arsenal eines Traders werden kann. Der von uns erstellte Indikator verwandelt chaotische Kursbewegungen in verständliche Muster und enthüllt verborgene Marktrhythmen nach Kalendertag des Monats, Wochentag oder Stunde der Handelssitzung.

Mit flexiblen Parametereinstellungen, der visuellen Darstellung der Ergebnisse in Form eines Histogramms mit Prognose und detaillierten Statistiken ermöglicht dieses Werkzeug Tradern nicht nur die Analyse historischer Daten, sondern auch, fundierte Einschätzungen zu künftigen Kursbewegungen abzuleiten. Die Integration von Prognoseelementen macht den Indikator praktisch anwendbar für die Entwicklung von Handelsstrategien.

Der Indikatorcode lässt sich leicht an verschiedene Vermögenswerte und Zeitrahmen anpassen, und eine schrittweise Erklärung jeder Funktion ermöglicht es uns, den Algorithmus an unsere eigenen Handelsideen anzupassen. Letztendlich ist dieser Indikator die Brücke zwischen komplexen statistischen Berechnungen und konkreten Handelsentscheidungen, die Daten in Wissen und Wissen in potenziellen Gewinn verwandelt.