Einführung in MQL5 (Teil 22): Aufbau eines Expert Advisors für das harmonische Muster 5-0

Einführung

Willkommen zurück zu Teil 22 der Serie der Einführung in MQL5! Im vorigen Artikel haben wir untersucht, wie man die Erkennung von harmonischen Mustern wie der Gartley-Formation in MQL5 automatisieren kann. In dieser Fortsetzung werden wir uns auf eine andere faszinierende, aber weniger verbreitete Struktur konzentrieren, die als 5-0 Harmonic Pattern bekannt ist. Dieses Muster zeichnet sich dadurch aus, dass im Gegensatz zu den meisten harmonischen Mustern, die mit einem Retracement beginnen, das 5-0-Muster mit einer scharfen Gegentrendbewegung beginnt, gefolgt von einer strukturierten Korrektur, die wertvolle Handelsmöglichkeiten bietet.

In diesem Artikel erfahren Sie, wie Sie das 5-0-Muster in einem Expert Advisor automatisch erkennen und programmatisch erfassen können. Sie lernen, die wichtigsten Umkehrpunkte der 5-0-Struktur (0, X, A, B, C und D) zu bestimmen, die spezifischen Fibonacci-Verhältnisse zu berechnen und zu validieren und das Muster visuell auf dem Chart darzustellen. Am Ende dieses Artikels werden Sie wissen, wie Sie die technische Idee, die dem 5-0-Muster zugrunde liegt, in funktionalen MQL5-Code umwandeln können, der die Preisbewegung automatisch analysieren kann.

 

Das harmonische Muster 5-0

Das harmonische Muster 5-0 ist eine Umkehrformation, die in der Regel nach einer signifikanten und lang anhaltenden Kursbewegung auftritt. Es wird eher als ein Muster der Fortsetzung hin zur Umkehr denn als ein reines Umkehrmuster angesehen und deutet auf eine mögliche Richtungsänderung des Trends hin. Die vier Strecken (XA, AB, BC und CD) werden durch die sechs Hauptpunkte des Musters gebildet: 0, X, A, B, C und D. Der markante Anfangspunkt und die Struktur des 5-0-Musters heben es von anderen harmonischen Mustern ab. Im Gegensatz zu den meisten harmonischen Mustern, die mit einem hohen oder tiefen Umkehrpunkt beginnen, beginnt das 5-0-Muster mit einer Korrekturbewegung, die häufig nach dem Ende eines vorangegangenen Trends oder Musters erfolgt. Sie zeichnet sich dadurch aus, dass sie darauf abzielt, die Erschöpfung einer gegenläufigen Bewegung und nicht den Beginn eines neuen Impulses zu erfassen.

Der Punkt 0, der ein klaren hohen Umkehrpunkt auf dem Chart bildet, ist der Ausgangspunkt des steigenden 5-0-Musters. Der Markt fällt von diesem Niveau ab und bildet den Punkt X, der den ersten signifikanten Abwärtstrend der Struktur darstellt. Ein korrigierender Rückzug dieses Rückgangs wird durch die anschließende Bewegung von X nach A dargestellt. Auch wenn es kein festgelegtes Fibonacci-Niveau für diesen Rückzug gibt, muss der Punkt A unter dem Punkt 0 liegen, um anzuzeigen, dass der Trend insgesamt noch rückläufig ist.

Nach der Etablierung von Punkt A sinkt der Markt weiter ab, um Punkt B zu erreichen, der zwischen der 113%- und 161,8%-Fibonacci-Ausdehnung der XA-Strecke liegt. Die Erschöpfungsphase des aktuellen Abwärtstrends wird häufig durch diese Strecke repräsentiert. Von Punkt B aus dreht der Markt wieder nach oben und bildet Punkt C, der in der Regel 161,8 % bis 224 % der AB-Strecke entspricht. Innerhalb des Musters stellt diese Bewegung eine starke Korrekturreaktion dar. Die Struktur wird am Punkt D vervollständigt, wo der Markt erneut einen Rücksetzer macht. Es wird empfohlen, dass Punkt D 50 % bis 55 % der BC-Strecke zurückgeht. Der mögliche Kaufbereich ist diese Retracement-Zone.

Punkt 0 bildet ein deutlichen tiefen Umkehrpunkt auf dem Chart und leitet das fallende 5-0-Muster ein. Der erste steigende Strecke des Musters entsteht, wenn der Markt von diesem Punkt bis zum Punkt X ansteigt. Obwohl es sich bei der anschließenden Bewegung von X nach A um einen korrigierenden Rückzug handelt, ist für diese Strecke kein präzises Fibonacci-Retracement erforderlich. Um sicherzustellen, dass der Gesamttrend derzeit noch positiv ist, muss Punkt A höher sein als Punkt 0.

Punkt B, der zwischen der 113%igen und 161,8%igen Fibonacci-Ausdehnung der XA-Strecke liegen sollte, entsteht, wenn der Kurs nach der Bildung von Punkt A erneut ansteigt. Normalerweise zeigt dieses Niveau an, dass der Aufwärtstrend sein Limit erreicht hat. Danach dreht der Markt wieder nach unten, um Punkt C zu bilden, der eine signifikante Musterkorrektur darstellen und zwischen 161,8 % und 224 % der AB-Strecke liegen dürfte. Die Struktur ist abgeschlossen, wenn der Kurs erneut ansteigt und den Punkt D erreicht. Es wird empfohlen, dass der Punkt D 50 % bis 55 % der BC-Strecke zurückgeht. Dieser Bereich des Retracements dient als möglicher Verkaufspunkt.

Identifizierung von 0XAB

Der nächste Schritt besteht darin, das 5-0-Muster in MQL5 programmatisch zu implementieren, nachdem wir nun seine Bedeutung und die wesentlichen Verhältnisprinzipien kennen. Dies bedeutet, dass die Idee in die Praxis umgesetzt werden muss, indem die Kerzendaten gesammelt und aktualisiert werden, die Umkehrpunkte genau identifiziert werden, potenzielle Sequenzen für 0, X, A, B, C und D zusammengestellt werden, jede Strecke gemäß den Verhältnisanforderungen des Musters verifiziert wird und die verifizierten Muster auf dem Chart gekennzeichnet werden.

In der Praxis werden wir einen einfachen Prozess befolgen: Wir kopieren die letzten Balken in Arrays, lokalisieren wichtige Umkehrpunkte mit einer zuverlässigen Erkennungstechnik der Umkehrpunkte und gehen dann durch diese Umkehrpunkte, um mögliche 0X-, XA-, AB- und BC-Strecken zu erstellen. Die Fibonacci-Extension- und Retracement-Kriterien werden dann verwendet, um zu überprüfen, ob die Punkte B, C und D gültig sind. Wenn alle Anforderungen erfüllt sind, werden wir als Nächstes die Erkennungslogik mit der Handelsausführung verbinden und das Muster und die Dreiecke zur visuellen Bestätigung zeichnen. Die Identifizierung des harmonischen 5-0-Musters im Aufwärtstrend steht zwar im Mittelpunkt dieses Artikels, es sei jedoch darauf hingewiesen, dass die gleiche Argumentation und das gleiche Verfahren zur Erkennung des 5-0-Musters im Abwärtstrend mit einigen leichten Richtungsänderungen ebenfalls verwendet werden können.

Das Kopieren von Kerzendaten und das Auffinden der 0XAB-Struktur ist der erste Schritt bei der Entwicklung des Erkennungsalgorithmus für das 5-0-Muster. Mit Hilfe der eingebauten Kopierfunktionen in MQL5 werden zunächst die aktuellen Marktdaten erfasst, einschließlich Eröffnungs-, Schluss-, Höchst- und Tiefstkursen sowie der Uhrzeit. Der Computer kann über diese Datenfelder auf historische Kursbewegungen zugreifen, was für die Identifizierung signifikanter Höchst- und Tiefststände von entscheidender Bedeutung ist.

Das Programm verwendet eine Logik zur Erkennung von Schwankungen, um mögliche Wendepunkte in der Preisentwicklung zu identifizieren, sobald die Daten verfügbar sind. Der EA verwendet diese Umkehrpunkte, um potenzielle 0-, X-, A- und B-Punkte zu bestimmen, die die Grundlage für das 5-0-Muster bilden. Ein großer hoher Umkehrpunkt wird durch den Punkt 0 und einen tiefen Umkehrpunkt durch den Punkt X repräsentiert. Dann dehnt sich der Punkt B entsprechend dem Fibonacci-Erweiterungsbereich (zwischen 113 % und 161,8 % von XA) über X hinaus aus, während der Punkt A als niedrigeres Hoch unter dem Punkt 0 entsteht. Da sie darüber entscheiden, ob sich das Muster zu einem legitimen steigenden 5-0-Setup entwickeln kann, wenn die Punkte C und D später bestätigt werden, ist die korrekte Erkennung dieser ersten vier Punkte von entscheidender Bedeutung.

Beispiel:

input ENUM_TIMEFRAMES timeframe = PERIOD_CURRENT;

datetime time_bar;
int bars_check = 400;
int total_symbol_bars;

double open[];
double close[];
double low[];
double high[];
datetime time[];

int z = 4;

double O;
datetime O_time;
string O_line;
string O_letter;

double X;
datetime X_time;
string X_letter;

double A;
datetime A_time;
string A_letter;

double B;
datetime B_time;
string B_line;
string B_letter;

double C;
datetime C_time;
string C_line;
string C_letter;

double D;
datetime D_time;
string D_line;
string D_letter;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---


//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---

   total_symbol_bars = Bars(_Symbol, timeframe);
   time_bar = iTime(_Symbol, timeframe, 0);
   CopyOpen(_Symbol, timeframe, time_bar, bars_check, open);
   CopyClose(_Symbol, timeframe, time_bar, bars_check, close);
   CopyLow(_Symbol, timeframe, time_bar, bars_check, low);
   CopyHigh(_Symbol, timeframe, time_bar, bars_check, high);
   CopyTime(_Symbol, timeframe, time_bar, bars_check, time);

  }

//+------------------------------------------------------------------+
//| FUNCTION FOR SWING LOW                                           |
//+------------------------------------------------------------------+
bool IsSwingLow(const double &low_price[], int index, int lookback)
  {
   for(int i = 1; i <= lookback; i++)
     {
      if(low_price[index] > low_price[index - i] || low_price[index] > low_price[index + i])
         return false;
     }
   return true;
  }

//+------------------------------------------------------------------+
//| FUNCTION FOR SWING HIGH                                          |
//+------------------------------------------------------------------+
bool IsSwingHigh(const double &high_price[], int index, int lookback)
  {
   for(int i = 1; i <= lookback; i++)
     {
      if(high_price[index] < high_price[index - i] || high_price[index] < high_price[index + i])
         return false; // If the current high is not the highest, return false.
     }
   return true;
  }

Erläuterung:

input ENUM_TIMEFRAMES timeframe = PERIOD_CURRENT;

Hier wird der Chart-Zeitrahmen angegeben, den der Expert Advisor (EA) untersuchen soll. Obwohl er standardmäßig den Zeitrahmen des aktuellen Charts verwendet, können Händler ihn leicht ändern, um den EA auf anderen Zeitrahmen zu testen, einschließlich M15, H1 oder D1, ohne den Grundcode zu ändern. 

Zur Verwaltung der Kerzendaten und der gesamten Chartinformationen werden dann eine Reihe von globalen Variablen deklariert:

datetime time_bar;
int bars_check = 400;
int total_symbol_bars;

double open[];
double close[];
double low[];
double high[];
datetime time[];

Zusammen speichern diese Variablen Marktdaten. Die Anzahl der Balken (Kerzen), die der EA untersuchen soll, wird durch die Variable bars_check festgelegt; in diesem Beispiel sind es die letzten 400 Kerzen. Die passenden Kerzendaten aus dem Chart werden dann in die Arrays geladen. Diese Datenfelder sind von entscheidender Bedeutung, da sie die Kurshistorie liefern, anhand derer die Höchst- und Tiefststände der Schwankungen ermittelt werden.

Das Programm definiert eine Reihe von Variablen, um die Besonderheiten jedes signifikanten Punktes im 5-0-Muster zu speichern, nachdem die grundlegenden Datencontainer deklariert wurden:

double O;
datetime O_time;
string O_line;
string O_letter;

double X;
datetime X_time;
string X_letter;

double A;
datetime A_time;
string A_letter;

double B;
datetime B_time;
string B_line;
string B_letter;

double C;
datetime C_time;
string C_line;
string C_letter;

double D;
datetime D_time;
string D_line;
string D_letter;

Jedem Umkehrpunkt ist eine eindeutige Sammlung von Variablen zugewiesen. O_time speichert beispielsweise die Zeit, zu der der O-Punkt aufgetreten ist, während O den Preis des O-Punkts speichert. Mit den Variablen O_line und O_letter kann der Punkt beschriftet und visuelle Markierungen auf dem Chart gezeichnet werden. Bei den Umkehrpunkten wiederholt sich das gleiche Muster. Diese Struktur ermöglicht es der Software, die Koordinaten jedes Punktes zu erfassen und das gesamte 5-0-Muster zu zeichnen, wenn alle Strecken überprüft sind.

Zur Ermittlung von tiefen Umkehrpunkten prüft die Funktion IsSwingLow, ob der Tiefstkurs eines Index niedriger ist als die Tiefstkurse der ihn umgebenden Kerzen. Der Parameter über die Rückblickzeitraum regelt die Anzahl der Kerzen, die vor und nach der aktuellen Kerze verglichen werden. Ein tiefer Umkehrpunkt wird verifiziert, wenn das Tief der Kerze tatsächlich das tiefste seiner Nachbarn ist. Um Wendepunkte zu erkennen, die die Basis des Musters von 0 oder X bilden könnten, sind tiefe Umkehrpunkten entscheidend. Innerhalb des angegebenen Rückblickbereichs prüft die Funktion IsSwingHigh zusätzlich, ob das Hoch einer Kerze höher ist als die Hochs der benachbarten Kerzen.

Das Auffinden der 0XAB-Formation ist der nächste Schritt nach der Festlegung des grundlegenden Rahmens für die Verwaltung der Marktdaten und die Ermittlung der Umkehrpunkte. Um bemerkenswerte Hochs und Tiefs zu finden, die den Wellen des steigenden 5-0-harmonischen Musters entsprechen, muss man die historischen Kerzendaten durchsuchen. Der Punkt X wird als unterer tiefer Umkehrpunkt und der Punkt 0 als signifikantes hoher Umkehrpunkt erkannt. Punkt B muss sich dann über den X-Punkt innerhalb des Fibonacci-Erweiterungsbereichs von 113 % bis 161,8 % der XA-Strecke hinaus erstrecken, woraufhin sich Punkt A als niedrigeres Hoch unterhalb von Punkt 0 bilden sollte.

Beispiel:

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---

   total_symbol_bars = Bars(_Symbol, timeframe);
   time_bar = iTime(_Symbol, timeframe, 0);
   CopyOpen(_Symbol, timeframe, time_bar, bars_check, open);
   CopyClose(_Symbol, timeframe, time_bar, bars_check, close);
   CopyLow(_Symbol, timeframe, time_bar, bars_check, low);
   CopyHigh(_Symbol, timeframe, time_bar, bars_check, high);
   CopyTime(_Symbol, timeframe, time_bar, bars_check, time);

   if(total_symbol_bars >= bars_check)
     {

      for(int i = z ; i < bars_check - z; i++)
        {
         if(IsSwingHigh(high, i, z))
           {

            for(int j = i; j < bars_check - z; j++)
              {

               if(IsSwingLow(low, j, z) && low[j] < high[i])
                 {

                  X = low[j];
                  X_time = time[j];
                  X_letter = StringFormat("X  %d",j);

                  for(int a = j; a >= i; a--)
                    {
                     if(IsSwingHigh(high, a, z) && high[a] > X)
                       {

                        O = high[a];
                        O_time = time[a];
                        O_letter = StringFormat("0  %d",a);

                        for(int k = j; k < bars_check - z; k++)
                          {

                           if(IsSwingHigh(high, k, z) && high[k] > X)
                             {

                              A = high[k];
                              A_time = time[k];
                              A_letter = StringFormat("A  %d",k);

                              for(int l = k; l < bars_check - z; l++)
                                {

                                 if(IsSwingLow(low, l, z) && low[l] < X)
                                   {
                                    B = low[l];
                                    B_time = time[l];
                                    B_letter = StringFormat("B  %d",l);

                                    break;
                                   }
                                }

                              break;
                             }
                          }

                        break;
                       }
                    }

                  break;
                 }
              }
           }
        }
     }
  }

Erläuterung:

Das Programm prüft zunächst, ob genügend Balken zur Analyse vorhanden sind. Die Suche wird nicht gestartet, wenn insgesamt weniger Balken vorhanden sind, als für die Analyse benötigt werden. Das ist so, als ob Sie sich vergewissern, dass Ihr Bücherregal voll ist, bevor Sie nach einer Folge suchen, denn wenn Sie das nicht tun, könnten Sie zu schnell zum Schluss kommen und das gesamte Muster verpassen.

Dann wird auf dem Chart nach einem ersten hohen Umkehrpunkt gesucht. Um festzustellen, ob es sich bei einem Balken an einer bestimmten Stelle um ein lokales Hoch handelt, prüft die äußere Schleife jeden Balken mithilfe der Funktion IsSwingHigh(). Dieser Ort wird zu einem möglichen Ausgangspunkt für die 5-0-Struktur, wenn diese Voraussetzung erfüllt ist.

Das Programm sucht nach einem tiefem Umkehrpunkt, das als Punkt X verwendet werden kann, nachdem ein hoher Umkehrpunkt identifiziert wurde. Dazu wird eine weitere Schleife verwendet, die am Hochpunkt beginnt und die Balken durchläuft, um ein Tief zu finden, der niedriger ist als das vorherige Hoch. Wenn die Kriterien erfüllt sind, werden der niedrigste Preis, der Zeitstempel und die Beschriftung für die Chartanzeige in der Variablen X gespeichert. Sie haben das nächste Buch in Ihrer möglichen Reihenfolge markiert, nachdem Sie ein kleineres gefunden haben, das etwas weiter unten im Regal steht als das große.

Der Algorithmus findet den richtigen Punkt 0, indem er sich nach seiner Erkennung von X aus rückwärts bewegt. Um die höchste Spitze zu finden, die über X liegt, wird die Suche zwischen X und dem ursprünglichen Höchststand umgekehrt. Der erste entdeckte Spitzenwert wird unter Angabe von Preis, Zeit und Etikett zum Punkt 0. Die Suche wird rückwärts durchgeführt, um sicherzustellen, dass der 0-Punkt der letzte Höchststand vor X ist.

Nach der Identifizierung der Punkte 0 und X sucht der Algorithmus erneut nach dem Punkt A. Wenn der folgende hohe Umkehrpunkt X überquert, sucht er danach und markiert ihn als A. Der Punkt A markiert den Beginn einer neuen Kurserholung innerhalb des sich entwickelnden Musters, indem er einen neuen Höchststand nach dem anfänglichen Rückgang darstellt. Dies zeigt an, dass sich Ihre Reihe immer noch in dem erwarteten alternierenden Muster bildet, ähnlich wie bei dem Beispiel des Bücherregals, wo ein mittelgroßes Buch auf ein kleines folgt.

Die Suche nach Punkt B ist der nächste Schritt. Um einen tiefen Umkehrpunkt zu finden, der unter X fällt, scannt der Code nach A weiter vorwärts. Der Preis, die Zeit und die Bezeichnung eines solchen Balkens werden als B notiert, wenn er gefunden wird. Der Code markiert dann B als den letzten Punkt der 0XAB-Sequenz und hört auf, nach weiteren Tiefs zu suchen. Die Gruppe aus vier Büchern, die die frühe Struktur des 5-0-Musters kennzeichnet, ist nun vollständig, da wir ein weiteres kleines Buch entdeckt haben, das in der Metapher des Bücherregals noch tiefer liegt als das vorangegangene kurze Buch.

Die inneren Schleifen dieser Sequenz verwenden alle Break-Befehle, um zu beenden, wenn ein gültiger Punkt erreicht ist. So bleibt die Erkennung zielgerichtet und effektiv, da der Algorithmus nicht viele sich überschneidende Sätze aus derselben Region erzeugt. Wenn Sie einen ordentlichen Stapel von Büchern zusammengestellt haben, der den Richtlinien für Höhe und Reihenfolge entspricht, hören wir mit dem Durchsuchen dieses Abschnitts auf und gehen zum nächsten über. Das Programm findet und speichert die ersten vier entscheidenden Punkte, 0, X, A und B, zusammen mit ihren Zeiten und Bezeichnungen nach diesen verschachtelten Schleifen korrekt.

Erinnern Sie sich daran, wie ich bereits sagte, dass der hoher Umkehrpunkt A, das ein Retracement von 0X ist, größer als X und kleiner als 0 sein muss, und dass der hoher Umkehrpunkt 0 größer als X sein muss. Aber für A ist kein bestimmter Fibonacci-Retracement-Prozentsatz erforderlich. Punkt B muss zwischen den Fibonacci-Erweiterungsniveaus der XA-Strecke von 113,0 % und 161,8 % liegen. Wir sollen ein Objekt auf dem Chart erstellen, um diese Musterentwicklung visuell zu identifizieren und auszudrücken, sobald der Algorithmus diese Bedingungen überprüft hat.

Beispiel:

input ENUM_TIMEFRAMES timeframe = PERIOD_CURRENT;
input double b_xa_max = 161.8; // MAX B EXTENSION LEVEL FOR XA
input double b_xa_min = 113.0; // MIN B EXTENSION LEVEL FOR XA

double fib_ext_b_161;
double fib_ext_b_113;
string fib_xa_ext_obj;
string fib_xa_ext_lvl;

string ox_line;
string xa_line;
string ab_line;
ulong chart_id = ChartID();

for(int l = k; l < bars_check - z; l++)
  {

   if(IsSwingLow(low, l, z) && low[l] < X)
     {

      B = low[l];
      B_time = time[l];
      B_letter = StringFormat("B  %d",l);

      fib_ext_b_113 =  MathAbs((((A - X) / 100) * (b_xa_min - 100)) - X);
      fib_ext_b_161 =   MathAbs((((A - X) / 100) * (b_xa_max - 100)) - X);

      if(X < O && A > X && A < O && B <= fib_ext_b_113 && B >= fib_ext_b_161)
        {

         ObjectCreate(chart_id,O_letter,OBJ_TEXT,0,O_time,O);
         ObjectSetString(chart_id,O_letter,OBJPROP_TEXT,"0");
         ObjectSetInteger(chart_id,O_letter,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,X_time,X);
         ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X");
         ObjectSetInteger(chart_id,X_letter,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,A_time,A);
         ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A");
         ObjectSetInteger(chart_id,A_letter,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,B_letter,OBJ_TEXT,0,B_time,B);
         ObjectSetString(chart_id,B_letter,OBJPROP_TEXT,"B");
         ObjectSetInteger(chart_id,B_letter,OBJPROP_COLOR,clrBlue);

         ox_line = StringFormat("0X Line  %d",i);
         xa_line = StringFormat("XA Line  %d",i);
         ab_line = StringFormat("AB Line  %d",i);

         ObjectCreate(chart_id,ox_line,OBJ_TREND,0, O_time, O,X_time,X);
         ObjectSetInteger(chart_id,ox_line,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,xa_line,OBJ_TREND,0, X_time, X,A_time,A);
         ObjectSetInteger(chart_id,xa_line,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,ab_line,OBJ_TREND,0, A_time, A,B_time,B);
         ObjectSetInteger(chart_id,ab_line,OBJPROP_COLOR,clrBlue);

         fib_xa_ext_obj = StringFormat("XA Expansion  %d",i);
         ObjectCreate(chart_id,fib_xa_ext_obj,OBJ_EXPANSION,0,A_time,A,X_time,X,A_time,A);
         ObjectSetInteger(chart_id,fib_xa_ext_obj,OBJPROP_COLOR,clrBlue);
         for(int i = 0; i <= 2; i++)
           {

            ObjectSetInteger(chart_id,fib_xa_ext_obj,OBJPROP_LEVELCOLOR,i,clrBlue);

           }

         fib_xa_ext_lvl = StringFormat("XA Expansion Levels %d",i);

         ObjectCreate(chart_id,fib_xa_ext_lvl,OBJ_RECTANGLE,0,X_time,fib_ext_b_113,B_time,fib_ext_b_161);
         ObjectSetInteger(chart_id,fib_xa_ext_lvl,OBJPROP_COLOR,clrBlue);

        }

      break;
     }
  }

Ausgabe:

Erläuterung:

Der Code deklariert zunächst ein paar Eingabevariablen. Das Programm verwendet automatisch denselben Zeitrahmen wie der Chart, auf den es angewendet wird. Als Nächstes wird der Fibonacci-Erweiterungsbereich der XA-Strecke durch zwei Eingaben dargestellt. Damit das Muster gültig ist, muss der Punkt B innerhalb des durch diese Werte definierten Bereichs liegen.

Die berechneten Werte und Objektnamen werden dann in einer Sammlung von Variablen gespeichert. Die berechneten Kursniveaus der Fibonacci-Extension, die 113% und 161,8% von XA entsprechen, werden anschließend von den Variablen fib_ext_b_113 und fib_ext_b_161 gehalten. Die verschiedenen grafischen Komponenten, die im Chart zur Veranschaulichung des identifizierten Musters dargestellt werden, werden mit den Variablen fib_xa_ext_obj, fib_xa_ext_lvl, ox_line, xa_line und ab_line bezeichnet. Um sicherzustellen, dass alle Zeichenaktivitäten im richtigen Chartfenster stattfinden, holt sich die Variable chart_id die ID des aktiven Charts.

Nach der Angabe dieser Variablen berechnet der Computer die Fibonacci-Erweiterungsniveaus anhand der mathematischen Korrelationen zwischen den Punkten A und X. Er bestimmt die Kurspunkte, die den 113%- und 161,8%-Erweiterungen von XA entsprechen. Um dies besser zu verstehen, sollten Sie den Abstand zwischen den Punkten X und A auf einem Regal messen. Die erste XA-Strecke wird durch die Basisdistanz (100 %) dargestellt, und die Ausdehnung des nächsten Punktes darüber hinaus wird durch die Erweiterungen 113 % und 161,8 % dargestellt. Der Punkt B muss innerhalb dieses zulässigen Bereichs liegen, der durch diese berechneten Werte bestimmt wird, damit das Muster rechtmäßig ist.

Eine bedingte Anweisung, die garantiert, dass alle notwendigen geometrischen und Fibonacci-Beziehungen des 5-0-Musters erfüllt sind, wird in der folgenden Codezeile eingeführt. Er hält die Preisstruktur von der Abwärts- zur Aufwärtsbewegung aufrecht, indem er feststellt, ob Punkt X unter Punkt 0 liegt. Darüber hinaus wird bestätigt, dass Punkt A innerhalb einer legitimen Retracement-Zone bleibt, indem er sich von X nach oben zurückzieht, ohne den Punkt 0 zu überschreiten. Schließlich wird überprüft, ob der Punkt B innerhalb von 113 % und 161,8 % von XA liegt, was dem zulässigen Fibonacci-Erweiterungsbereich entspricht.

Der Algorithmus zeichnet dann die ermittelte Struktur auf das Chart, wenn alle diese Anforderungen erfüllt sind. Es beginnt damit, dass die wichtigen Umkehrpunkte (0, X, A und B) mit Textobjekten benannt werden. Zur besseren Erkennbarkeit sind die Textelemente blau eingefärbt. Diese Bezeichnungen erleichtern es den Händlern, die wesentliche Struktur des Musters zu erkennen.

Der Code beschriftet die Orte und verbindet dann 0X, XA und AB mit Trendlinien. Die Bewegung der Kursausschläge, die als Grundlage für das 5-0-Muster dienen, wird durch jede dieser Linien grafisch dargestellt. Die Bezeichnung jeder Linie (z. B. „0X-Linie“ oder „XA-Linie“) garantiert, dass jedes Element im Chart eindeutig und einfach zu erkennen ist.

Danach werden potenzielle Erweiterungszonen mit Hilfe des Fibonacci-Expansionstools visuell zwischen den XA-Strecken projiziert. Diese Ausdehnung stärkt die Verbindung, die die Richtigkeit von Punkt B begründet, indem sie den Händlern zeigt, wie weit sich der Preis über XA hinaus ausgedehnt haben kann. Um den Bereich zwischen der 113%igen und der 161,8%igen Ausdehnung visuell hervorzuheben, wird schließlich ein Rechteck gezeichnet. Dieser rechteckige Bereich verdeutlicht die erwartete Bildung von Punkt B, indem er als hervorgehobener Regalteil fungiert. Punkt B kann uns bei der visuellen Überprüfung des harmonischen Setups auf unseren Charts unterstützen, indem er eine geeignete Erweiterungszone für das mögliche 5-0-Muster angibt, wenn es in diesen Bereich fällt.

Identifizierung von C

Das Auffinden der Punkte C und D vervollständigt die 5-0-Musterstruktur, nachdem die Punkte 0, X, A und B korrekt lokalisiert wurden. Diese beiden Punkte sind von entscheidender Bedeutung, da sie darüber entscheiden, ob sich die festgestellte Situation zu einer rechtmäßigen harmonischen Formation entwickelt. Je nachdem, wie der Kurs auf B reagiert, kann sich Punkt C als Ausdehnung oder Retracement der AB-Strecke bilden. C wird voraussichtlich zwischen 161,8 % und 224 % Fibonacci-Erweiterung von AB im Falle des fallendes 5-0-Musters liegen. Dies bedeutet, dass sich der Kurs über das Ende von AB hinaus um etwa das 1,618- bis 2,24-fache der Entfernung von AB bewegen sollte, sobald er Punkt B erreicht.

Mit anderen Worten: Stellen Sie sich die AB-Strecke als Teil eines Regals vor. Die Platzierung eines neuen Buches (C) weiter entlang dieses Regals, nicht zu nahe an B (weniger als 161,8%) und nicht zu weit entfernt (über 224%), ist das, was passiert, wenn der Preis über B hinausgeht. Diese Zone, die anzeigt, dass der Markt sich ausreichend ausgedehnt hat, um das harmonische Gleichgewicht zu bewahren, ohne darüber hinauszugehen, ist der ideale Bereich für die Ankunft von C.

Nach der Bestimmung des Punktes C wird die Struktur durch die Bestimmung des Punktes D als Retracement der BC-Strecke vervollständigt. Die Überprüfung des fallendes 5-0-Setups vor der Anwendung einer Handelsbestätigung oder Alarmlogik erfordert, dass sowohl C als auch D richtig ausgerichtet sind, damit das Muster seine harmonische Symmetrie beibehält.

Beispiel:

input double c_ab_max = 224.0; // MAX C EXTENSION LEVEL FOR AB
input double c_ab_min = 161.8; // MIN C EXTENSION LEVEL FOR AB

double fib_ext_c_161;
double fib_ext_c_224;
string fib_ab_ext_obj;
string fib_ab_ext_lvl;
string bc_line;

if(total_symbol_bars >= bars_check)
  {
   for(int i = z ; i < bars_check - z; i++)
     {
      if(IsSwingHigh(high, i, z))
        {
         for(int j = i; j < bars_check - z; j++)
           {
            if(IsSwingLow(low, j, z) && low[j] < high[i])
              {
               X = low[j];
               X_time = time[j];
               X_letter = StringFormat("X  %d",j);

               for(int a = j; a >= i; a--)
                 {
                  if(IsSwingHigh(high, a, z) && high[a] > X)
                    {
                     O = high[a];
                     O_time = time[a];
                     O_letter = StringFormat("0  %d",a);

                     for(int k = j; k < bars_check - z; k++)
                       {

                        if(IsSwingHigh(high, k, z) && high[k] > X)
                          {
                           A = high[k];
                           A_time = time[k];
                           A_letter = StringFormat("A  %d",k);

                           for(int l = k; l < bars_check - z; l++)
                             {

                              if(IsSwingLow(low, l, z) && low[l] < X)
                                {
                                 B = low[l];
                                 B_time = time[l];
                                 B_letter = StringFormat("B  %d",l);

                                 for(int m = l; m < bars_check - z; m++)
                                   {

                                    if(IsSwingHigh(high, m, z) && high[m] > A)
                                      {

                                       C = high[m];
                                       C_time = time[m];
                                       C_letter = StringFormat("C  %d",m);

                                       fib_ext_b_113 =  MathAbs((((A - X) / 100) * (b_xa_min - 100)) - X);
                                       fib_ext_b_161 =   MathAbs((((A - X) / 100) * (b_xa_max - 100)) - X);

                                       fib_ext_c_161 = MathAbs((((A - B) / 100) * (c_ab_min - 100)) + A);
                                       fib_ext_c_224 =    MathAbs((((A - B) / 100) * (c_ab_max - 100)) + A);

                                       if(X < O && A > X && A < O && B <= fib_ext_b_113 && B >= fib_ext_b_161 && C >= fib_ext_c_161 && C <= fib_ext_c_224)
                                         {
                                          ObjectCreate(chart_id,O_letter,OBJ_TEXT,0,O_time,O);
                                          ObjectSetString(chart_id,O_letter,OBJPROP_TEXT,"0");
                                          ObjectSetInteger(chart_id,O_letter,OBJPROP_COLOR,clrBlue);

                                          ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,X_time,X);
                                          ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X");
                                          ObjectSetInteger(chart_id,X_letter,OBJPROP_COLOR,clrBlue);

                                          ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,A_time,A);
                                          ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A");
                                          ObjectSetInteger(chart_id,A_letter,OBJPROP_COLOR,clrBlue);

                                          ObjectCreate(chart_id,B_letter,OBJ_TEXT,0,B_time,B);
                                          ObjectSetString(chart_id,B_letter,OBJPROP_TEXT,"B");
                                          ObjectSetInteger(chart_id,B_letter,OBJPROP_COLOR,clrBlue);

                                          ox_line = StringFormat("0X Line  %d",i);
                                          xa_line = StringFormat("XA Line  %d",i);
                                          ab_line = StringFormat("AB Line  %d",i);

                                          ObjectCreate(chart_id,ox_line,OBJ_TREND,0, O_time, O,X_time,X);
                                          ObjectSetInteger(chart_id,ox_line,OBJPROP_COLOR,clrBlue);

                                          ObjectCreate(chart_id,xa_line,OBJ_TREND,0, X_time, X,A_time,A);
                                          ObjectSetInteger(chart_id,xa_line,OBJPROP_COLOR,clrBlue);

                                          ObjectCreate(chart_id,ab_line,OBJ_TREND,0, A_time, A,B_time,B);
                                          ObjectSetInteger(chart_id,ab_line,OBJPROP_COLOR,clrBlue);

                                          fib_xa_ext_obj = StringFormat("XA Expansion  %d",i);
                                          ObjectCreate(chart_id,fib_xa_ext_obj,OBJ_EXPANSION,0,A_time,A,X_time,X,A_time,A);
                                          ObjectSetInteger(chart_id,fib_xa_ext_obj,OBJPROP_COLOR,clrBlue);
                                          for(int i = 0; i <= 2; i++)
                                            {
                                             ObjectSetInteger(chart_id,fib_xa_ext_obj,OBJPROP_LEVELCOLOR,i,clrBlue);
                                            }

                                          fib_xa_ext_lvl = StringFormat("XA Expansion Levels %d",i);

                                          ObjectCreate(chart_id,fib_xa_ext_lvl,OBJ_RECTANGLE,0,X_time,fib_ext_b_113,B_time,fib_ext_b_161);
                                          ObjectSetInteger(chart_id,fib_xa_ext_lvl,OBJPROP_COLOR,clrBlue);

                                          ObjectCreate(chart_id,C_letter,OBJ_TEXT,0,C_time,C);
                                          ObjectSetString(chart_id,C_letter,OBJPROP_TEXT,"C");
                                          ObjectSetInteger(chart_id,C_letter,OBJPROP_COLOR,clrBlue);

                                          bc_line = StringFormat("BC Line  %d",i);
                                          ObjectCreate(chart_id,bc_line,OBJ_TREND,0, B_time, B,C_time,C);
                                          ObjectSetInteger(chart_id,bc_line,OBJPROP_COLOR,clrBlue);

                                          fib_ab_ext_obj = StringFormat("AB Expansion  %d",i);
                                          ObjectCreate(chart_id,fib_ab_ext_obj,OBJ_EXPANSION,0,B_time,B,A_time,A,B_time,B);
                                          ObjectSetInteger(chart_id,fib_ab_ext_obj,OBJPROP_COLOR,clrBlue);
                                          for(int i = 0; i <= 2; i++)
                                            {

                                             ObjectSetInteger(chart_id,fib_ab_ext_obj,OBJPROP_LEVELCOLOR,i,clrBlue);

                                            }

                                          fib_ab_ext_lvl = StringFormat("AB Expansion Levels %d",i);

                                          ObjectCreate(chart_id,fib_ab_ext_lvl,OBJ_RECTANGLE,0,A_time,fib_ext_c_161,C_time,fib_ext_c_224);
                                          ObjectSetInteger(chart_id,fib_ab_ext_lvl,OBJPROP_COLOR,clrBlue);

                                         }

                                       break;
                                      }
                                   }
                                 break;
                                }
                             }
                           break;
                          }
                       }
                     break;
                    }
                 }
               break;
              }
           }
        }
     }
  }

Ausgabe:

Erläuterung:

Um zu verhindern, dass sich der Punkt C zu weit über die AB-Distanz hinaus ausdehnt, wird das maximal zulässige Fibonacci-Erweiterungsniveau für die AB-Strecke auf 224 % festgelegt. Um zu verhindern, dass sich Punkt C zu nahe an Punkt B bildet, wird die minimale Fibonacci-Extension-Ebene ebenfalls auf 161,8 % festgelegt. Die zulässige Preiszone, in der Punkt C erwartet wird, wird durch diese beiden Niveaus zusammen definiert. Zusätzlich stehen eine Reihe von Variablen zur Berechnung und Anzeige bereit. Zur besseren Übersichtlichkeit der Musterstruktur erstellen sie die Trendlinie, die die Punkte B und C verbindet, speichern die berechneten Fibonacci-Extension-Levels und kontrollieren die Fibonacci-Expansion und die dazugehörige visuelle Darstellung im Chart.

Das Programm protokolliert den Preis, die Zeit und das Label als Referenz, wenn es ein möglicher hoher Umkehrpunkt erkennt, das die Kriterien für Punkt C erfüllt. Um den legitimen Bereich für Punkt B zu überprüfen und die voraussichtliche Preiszone für Punkt C zu ermitteln, werden die Fibonacci-Extension-Levels dann neu berechnet. Diese Berechnungen bestimmen die 161,8%- und 224%-Erweiterungsschwellen, die angeben, wo Punkt C idealerweise erscheinen sollte, abhängig von der Differenz zwischen den Punkten A und B. Der Expert Advisor kann mit diesem Verfahren überprüfen, ob der erkannte Umkehrpunkt tatsächlich innerhalb der zulässigen Grenzen des 5-0-Musters liegt.

Anhand einer bedingten Anweisung stellt der Computer fest, ob alle Punkte des Musters korrekt ausgerichtet sind. A ist größer als X, aber kleiner als O, B liegt zwischen 113% und 161,8% von XA, und C liegt zwischen 161,8% und 224% der Fibonacci-Erweiterung von AB. Es bestätigt, dass X niedriger als O ist. Eine legitime 0XABC-Struktur für ein mögliches steigendes 5-0-Muster wird bestätigt, wenn alle diese geometrischen und Fibonacci-Regeln erfüllt sind.

Der EA stellt das Muster im Chart grafisch dar, nachdem diese Anforderung erfüllt ist. Nach der Erstellung einer Textbeschriftung für C und dem Zeichnen einer Linie zwischen B und C wird die Erweiterungszone für C durch Hinzufügen eines Rechtecks und eines Fibonacci-Erweiterungsobjekts angezeigt. Das Rechteck zeigt den Händlern genau, wo C im Verhältnis zu AB aufgetreten ist, und hebt den Bereich von 161,8 % bis 224 % hervor.

 

Identifizierung von D

Punkt D ist die letzte Welle des steigenden 5-0 harmonischen Musters und vervollständigt die gesamte Struktur. Das Auffinden von D innerhalb des korrekten Fibonacci-Retracement-Bereichs ist der letzte Schritt nach der Identifizierung und Validierung der Punkte 0, X, A, B und C. Punkt D ist die Abschlusszone des Musters und bezeichnet häufig die Region, in der Händler eine mögliche Aufwärtsumkehr erwarten.

Punkt D muss sich zwischen dem 50%- und 55%-Fibonacci-Retracement der BC-Strecke entwickeln, damit ein steigendes 5-0-Setup als legitim angesehen werden kann. Das harmonische Gleichgewicht, das die Struktur des Musters ausmacht, wird durch diese Retracement-Zone hergestellt. D dürfte also etwa die Hälfte der BC-Bewegung zurückgehen, was darauf hindeutet, dass die Abwärtskorrektur von C zu einem Ende kommen könnte.

Beispiel:

input double d_bc_max = 55.0; // MAX D RETRACEMENT LEVEL FOR BC
input double d_bc_min = 50.0; // MIN D RETRACEMENT LEVEL FOR BC

double fib_ret_d_50;
double fib_ret_d_55;
string fib_bc_ret_lvl;
string cd_line;

for(int n = m; n < bars_check - z; n++)
  {
   if(IsSwingLow(low, n, z) && low[n] < C)
     {

      D = low[n];
      D_time = time[n];
      D_letter = StringFormat("D  %d",l);
      cd_line = StringFormat("CD %d",i);

      fib_ext_b_113 =  MathAbs((((A - X) / 100) * (b_xa_min - 100)) - X);
      fib_ext_b_161 =   MathAbs((((A - X) / 100) * (b_xa_max - 100)) - X);

      fib_ext_c_161 = MathAbs((((A - B) / 100) * (c_ab_min - 100)) + A);
      fib_ext_c_224 =    MathAbs((((A - B) / 100) * (c_ab_max - 100)) + A);

      fib_ret_d_50 = C - ((d_bc_min / 100) * (C - B));
      fib_ret_d_55 = C - ((d_bc_max / 100) * (C - B));

      if(X < O && A > X && A < O && B <= fib_ext_b_113 && B >= fib_ext_b_161 && C >= fib_ext_c_161 && C <= fib_ext_c_224 && D <= fib_ret_d_50 && D >= fib_ret_d_55)
        {
         ObjectCreate(chart_id,O_letter,OBJ_TEXT,0,O_time,O);
         ObjectSetString(chart_id,O_letter,OBJPROP_TEXT,"0");
         ObjectSetInteger(chart_id,O_letter,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,X_time,X);
         ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X");
         ObjectSetInteger(chart_id,X_letter,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,A_time,A);
         ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A");
         ObjectSetInteger(chart_id,A_letter,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,B_letter,OBJ_TEXT,0,B_time,B);
         ObjectSetString(chart_id,B_letter,OBJPROP_TEXT,"B");
         ObjectSetInteger(chart_id,B_letter,OBJPROP_COLOR,clrBlue);

         ox_line = StringFormat("0X Line  %d",i);
         xa_line = StringFormat("XA Line  %d",i);
         ab_line = StringFormat("AB Line  %d",i);

         ObjectCreate(chart_id,ox_line,OBJ_TREND,0, O_time, O,X_time,X);
         ObjectSetInteger(chart_id,ox_line,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,xa_line,OBJ_TREND,0, X_time, X,A_time,A);
         ObjectSetInteger(chart_id,xa_line,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,ab_line,OBJ_TREND,0, A_time, A,B_time,B);
         ObjectSetInteger(chart_id,ab_line,OBJPROP_COLOR,clrBlue);

         fib_xa_ext_obj = StringFormat("XA Expansion  %d",i);
         ObjectCreate(chart_id,fib_xa_ext_obj,OBJ_EXPANSION,0,A_time,A,X_time,X,A_time,A);
         ObjectSetInteger(chart_id,fib_xa_ext_obj,OBJPROP_COLOR,clrBlue);
         for(int i = 0; i <= 2; i++)
           {
            ObjectSetInteger(chart_id,fib_xa_ext_obj,OBJPROP_LEVELCOLOR,i,clrBlue);
           }
         fib_xa_ext_lvl = StringFormat("XA Expansion Levels %d",i);

         ObjectCreate(chart_id,fib_xa_ext_lvl,OBJ_RECTANGLE,0,X_time,fib_ext_b_113,B_time,fib_ext_b_161);
         ObjectSetInteger(chart_id,fib_xa_ext_lvl,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,C_letter,OBJ_TEXT,0,C_time,C);
         ObjectSetString(chart_id,C_letter,OBJPROP_TEXT,"C");
         ObjectSetInteger(chart_id,C_letter,OBJPROP_COLOR,clrBlue);

         bc_line = StringFormat("BC Line  %d",i);
         ObjectCreate(chart_id,bc_line,OBJ_TREND,0, B_time, B,C_time,C);
         ObjectSetInteger(chart_id,bc_line,OBJPROP_COLOR,clrBlue);

         fib_ab_ext_obj = StringFormat("AB Expansion  %d",i);
         ObjectCreate(chart_id,fib_ab_ext_obj,OBJ_EXPANSION,0,B_time,B,A_time,A,B_time,B);
         ObjectSetInteger(chart_id,fib_ab_ext_obj,OBJPROP_COLOR,clrBlue);
         for(int i = 0; i <= 2; i++)
           {

            ObjectSetInteger(chart_id,fib_ab_ext_obj,OBJPROP_LEVELCOLOR,i,clrBlue);

           }

         fib_ab_ext_lvl = StringFormat("AB Expansion Levels %d",i);

         ObjectCreate(chart_id,fib_ab_ext_lvl,OBJ_RECTANGLE,0,A_time,fib_ext_c_161,C_time,fib_ext_c_224);
         ObjectSetInteger(chart_id,fib_ab_ext_lvl,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,D_letter,OBJ_TEXT,0,D_time,D);
         ObjectSetString(chart_id,D_letter,OBJPROP_TEXT,"D");
         ObjectSetInteger(chart_id,D_letter,OBJPROP_COLOR,clrBlue);

         cd_line = StringFormat("CD Line  %d",i);
         ObjectCreate(chart_id,cd_line,OBJ_TREND,0, C_time, C,D_time,D);
         ObjectSetInteger(chart_id,cd_line,OBJPROP_COLOR,clrBlue);

         fib_bc_ret_lvl = StringFormat("BC RETRACEMENT Levels %d",i);

         ObjectCreate(chart_id,fib_bc_ret_lvl,OBJ_RECTANGLE,0,B_time,fib_ret_d_50,D_time,fib_ret_d_55);
         ObjectSetInteger(chart_id,fib_bc_ret_lvl,OBJPROP_COLOR,clrBlue);

        }

      break;
     }
  }

Ausgabe:

Erläuterung:

Fib_ret_d_50 und fib_ret_d_55 sind zwei Variablen, die verwendet werden, um die genauen Retracement-Niveaus zu bestimmen, bei denen D auftreten kann. Die Berechnung multipliziert die Differenz zwischen C und B mit der dezimalen Darstellung des Retracement-Prozentsatzes und subtrahiert dann das Ergebnis von C. Dies liefert die Kursniveaus, die die Retracement-Zone von Punkt D abgrenzen. Die richtige Platzierung von D innerhalb der voraussichtlichen Fibonacci-Retracement-Grenze wird durch die Formel garantiert.

Das Programm stellt fest, ob die gesamte 5-0-Musterstruktur die notwendigen harmonischen Anforderungen erfüllt, nachdem die Retracement-Levels bestimmt wurden. Der Punkt D liegt innerhalb des 50% bis 55%igen Retracement-Bereichs von BC, während die Punkte B und C sich zwischen 113% und 161,8% der XA-Strecke erstrecken, der Punkt C zwischen 161,8% und 224% der AB-Ausdehnung liegt und der Punkt X den Umständen entsprechend niedriger ist als O. Die Struktur wird nur dann als legitimes 5-0-Muster betrachtet, wenn alle diese Beziehungen erfüllt sind.

Nach der Validierung verwendet der Computer das Chart, um die Struktur visuell darzustellen. An der Position D wird eine Textbeschriftung „D“ angebracht, um die Position anzugeben. Der letzte Abschnitt des Musters wird dann offensichtlich angezeigt, wenn eine Linie zwischen C und D gezogen wird, um die CD-Strecke zu erzeugen. Um die mögliche Abschlusszone für Punkt D visuell darzustellen, wird ebenfalls ein Rechteck erstellt, um den Bereich des 50%- bis 55%-Retracements hervorzuheben. Dies macht es für Händler einfach, potenzielle Umkehrungen oder Abschlüsse in Echtzeit zu erkennen.

Der nächste Schritt ist die Überprüfung, ob jeder identifizierte Punkt die vorherrschende Bewegung innerhalb des entsprechenden Strecke genau wiedergibt. Da geringfügige Preisänderungen die Gesamtstruktur des Musters verfälschen und zu Verwirrung oder irreführenden Signalen führen können, ist die bloße Aufzeichnung von Höchst- und Tiefstständen nicht ausreichend. Um die Genauigkeit zu gewährleisten, müssen klare Richtlinien für die Überprüfung der einzelnen Umkehrpunkte entwickelt werden.

Es muss der höchste Wert zwischen den Punkten 0 und X sein, beginnend bei Punkt 0. Dies garantiert, dass ein echter hoher Umkehrpunkt und nicht nur ein leichter Kursanstieg den Beginn der ersten Abwärtsbewegung (0X) markiert. Von den Punkten X und A muss jedoch der Punkt X der niedrigste sein. Dies zeigt, dass die XA-Strecke mit einem echten tiefen Umkehrpunkt und nicht mit einem vorübergehenden Abfall beginnt.

In ähnlicher Weise muss Punkt A das höchste Hoch zwischen den Punkten A und B sein, um zu gewährleisten, dass die AB-Strecke ein legitimer hoher Umkehrpunkt widerspiegelt. Die BC-Strecke muss dann von einem dominanten Tiefpunkt zurückgehen, wenn Punkt B das niedrigste Tief zwischen den Punkten B und C ist. Um zu gewährleisten, dass die CD-Strecke von einem echten hohen Umkehrpunkt ausgeht, muss Punkt C das höchste Hoch zwischen den Punkten C und D sein.

Beispiel:

int c_d_bars;
int c_highest_index;
double c_d_hh;
datetime c_d_hh_t;

int b_c_bars;
int b_lowest_index;
double b_c_ll;
datetime b_c_ll_t;

int a_b_bars;
int a_highest_index;
double a_b_hh;
datetime a_b_hh_t;

int x_a_bars;
int x_lowest_index;
double x_a_ll;
datetime x_a_ll_t;

int o_x_bars;
int o_highest_index;
double o_x_hh;
datetime o_x_hh_t;

for(int n = m; n < bars_check - z; n++)
  {
   if(IsSwingLow(low, n, z) && low[n] < C)
     {

      D = low[n];
      D_time = time[n];
      D_letter = StringFormat("D  %d",l);
      cd_line = StringFormat("CD %d",i);

      c_d_bars = Bars(_Symbol,PERIOD_CURRENT,C_time,D_time);
      c_highest_index = ArrayMaximum(high,m,c_d_bars);
      c_d_hh = high[c_highest_index];
      c_d_hh_t = time[c_highest_index];

      b_c_bars = Bars(_Symbol,PERIOD_CURRENT,B_time,c_d_hh_t);
      b_lowest_index = ArrayMinimum(low,l,b_c_bars);
      b_c_ll = low[b_lowest_index];
      b_c_ll_t = time[b_lowest_index];

      a_b_bars = Bars(_Symbol,PERIOD_CURRENT,A_time,b_c_ll_t);
      a_highest_index = ArrayMaximum(high,k,a_b_bars);
      a_b_hh = high[a_highest_index];
      a_b_hh_t = time[a_highest_index];

      x_a_bars = Bars(_Symbol,PERIOD_CURRENT,X_time,a_b_hh_t);
      x_lowest_index = ArrayMinimum(low,j,x_a_bars);
      x_a_ll = low[x_lowest_index];
      x_a_ll_t = time[x_lowest_index];

      o_x_bars = Bars(_Symbol,PERIOD_CURRENT,O_time,x_a_ll_t);
      o_highest_index = ArrayMaximum(high,a,o_x_bars);
      o_x_hh = high[o_highest_index];
      o_x_hh_t = time[o_highest_index];

      fib_ext_b_113 =  MathAbs((((a_b_hh - x_a_ll) / 100) * (b_xa_min - 100)) - x_a_ll);
      fib_ext_b_161 =   MathAbs((((a_b_hh - x_a_ll) / 100) * (b_xa_max - 100)) - x_a_ll);

      fib_ext_c_161 = MathAbs((((a_b_hh - b_c_ll) / 100) * (c_ab_min - 100)) + a_b_hh);
      fib_ext_c_224 =    MathAbs((((a_b_hh - b_c_ll) / 100) * (c_ab_max - 100)) + a_b_hh);

      fib_ret_d_50 = c_d_hh - ((d_bc_min / 100) * (c_d_hh - b_c_ll));
      fib_ret_d_55 = c_d_hh - ((d_bc_max / 100) * (c_d_hh - b_c_ll));

      if(x_a_ll < o_x_hh && a_b_hh > x_a_ll && a_b_hh < o_x_hh && b_c_ll <= fib_ext_b_113 && b_c_ll >= fib_ext_b_161 && c_d_hh >= fib_ext_c_161 && c_d_hh <= fib_ext_c_224 && D <= fib_ret_d_50 && D >= fib_ret_d_55)
        {
         ObjectCreate(chart_id,O_letter,OBJ_TEXT,0,o_x_hh_t,o_x_hh);
         ObjectSetString(chart_id,O_letter,OBJPROP_TEXT,"0");
         ObjectSetInteger(chart_id,O_letter,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,x_a_ll_t,x_a_ll);
         ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X");
         ObjectSetInteger(chart_id,X_letter,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,a_b_hh_t,a_b_hh);
         ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A");
         ObjectSetInteger(chart_id,A_letter,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,B_letter,OBJ_TEXT,0,b_c_ll_t,b_c_ll);
         ObjectSetString(chart_id,B_letter,OBJPROP_TEXT,"B");
         ObjectSetInteger(chart_id,B_letter,OBJPROP_COLOR,clrBlue);

         ox_line = StringFormat("0X Line  %d",i);
         xa_line = StringFormat("XA Line  %d",i);
         ab_line = StringFormat("AB Line  %d",i);

         ObjectCreate(chart_id,ox_line,OBJ_TREND,0, o_x_hh_t, o_x_hh,x_a_ll_t,x_a_ll);
         ObjectSetInteger(chart_id,ox_line,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,xa_line,OBJ_TREND,0, x_a_ll_t, x_a_ll,a_b_hh_t,a_b_hh);
         ObjectSetInteger(chart_id,xa_line,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,ab_line,OBJ_TREND,0, a_b_hh_t, a_b_hh,b_c_ll_t,b_c_ll);
         ObjectSetInteger(chart_id,ab_line,OBJPROP_COLOR,clrBlue);

         fib_xa_ext_obj = StringFormat("XA Expansion  %d",i);
         ObjectCreate(chart_id,fib_xa_ext_obj,OBJ_EXPANSION,0,a_b_hh_t,a_b_hh,x_a_ll_t,x_a_ll,a_b_hh_t,a_b_hh);
         ObjectSetInteger(chart_id,fib_xa_ext_obj,OBJPROP_COLOR,clrBlue);
         for(int i = 0; i <= 2; i++)
           {
            ObjectSetInteger(chart_id,fib_xa_ext_obj,OBJPROP_LEVELCOLOR,i,clrBlue);
           }

         fib_xa_ext_lvl = StringFormat("XA Expansion Levels %d",i);

         ObjectCreate(chart_id,fib_xa_ext_lvl,OBJ_RECTANGLE,0,x_a_ll_t,fib_ext_b_113,b_c_ll_t,fib_ext_b_161);
         ObjectSetInteger(chart_id,fib_xa_ext_lvl,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,C_letter,OBJ_TEXT,0,c_d_hh_t,c_d_hh);
         ObjectSetString(chart_id,C_letter,OBJPROP_TEXT,"C");
         ObjectSetInteger(chart_id,C_letter,OBJPROP_COLOR,clrBlue);

         bc_line = StringFormat("BC Line  %d",i);
         ObjectCreate(chart_id,bc_line,OBJ_TREND,0, b_c_ll_t, b_c_ll,c_d_hh_t,c_d_hh);
         ObjectSetInteger(chart_id,bc_line,OBJPROP_COLOR,clrBlue);

         fib_ab_ext_obj = StringFormat("AB Expansion  %d",i);
         ObjectCreate(chart_id,fib_ab_ext_obj,OBJ_EXPANSION,0,b_c_ll_t,b_c_ll,a_b_hh_t,a_b_hh,b_c_ll_t,b_c_ll);
         ObjectSetInteger(chart_id,fib_ab_ext_obj,OBJPROP_COLOR,clrBlue);
         for(int i = 0; i <= 2; i++)
           {
            ObjectSetInteger(chart_id,fib_ab_ext_obj,OBJPROP_LEVELCOLOR,i,clrBlue);
           }

         fib_ab_ext_lvl = StringFormat("AB Expansion Levels %d",i);

         ObjectCreate(chart_id,fib_ab_ext_lvl,OBJ_RECTANGLE,0,a_b_hh_t,fib_ext_c_161,c_d_hh_t,fib_ext_c_224);
         ObjectSetInteger(chart_id,fib_ab_ext_lvl,OBJPROP_COLOR,clrBlue);

         ObjectCreate(chart_id,D_letter,OBJ_TEXT,0,D_time,D);
         ObjectSetString(chart_id,D_letter,OBJPROP_TEXT,"D");
         ObjectSetInteger(chart_id,D_letter,OBJPROP_COLOR,clrBlue);

         cd_line = StringFormat("CD Line  %d",i);
         ObjectCreate(chart_id,cd_line,OBJ_TREND,0, C_time, C,D_time,D);
         ObjectSetInteger(chart_id,cd_line,OBJPROP_COLOR,clrBlue);

         fib_bc_ret_lvl = StringFormat("BC RETRACEMENT Levels %d",i);

         ObjectCreate(chart_id,fib_bc_ret_lvl,OBJ_RECTANGLE,0,b_c_ll_t,fib_ret_d_50,D_time,fib_ret_d_55);
         ObjectSetInteger(chart_id,fib_bc_ret_lvl,OBJPROP_COLOR,clrBlue);

        }
      break;
     }
  }

Erläuterung:

Um sicherzustellen, dass jeder Punkt einen Umkehrpunkt des Marktes korrekt abbildet, wird das gleiche Validierungsverfahren für die verbleibenden Strecken angewendet. Der Algorithmus bestimmt das niedrigste Tief zwischen X und A für die XA-Strecke, sodass X als tiefer Umkehrpunkt bestätigt wird. Um zu gewährleisten, dass 0 der dominante hohe Umkehrpunkt zu Beginn des Musters darstellt, sucht die 0X-Strecke in ähnlicher Weise nach dem höchsten Hoch zwischen 0 und X. Durch diese Methode der Bewertung jedes Punktes bleibt die Struktur des Musters stabil und verlässlich, während falsche Schwünge, die die Genauigkeit der Identifizierung verfälschen könnten, ausgeschlossen werden.

Das Programm stellt sicher, dass alle kürzlich verifizierten Hochs und Tiefs in die späteren Berechnungen einfließen, nachdem es jeden dominierenden Umkehrpunkt validiert hat. Diese Verbesserung ermöglicht eine präzisere Neuberechnung der Fibonacci-Extension- und Retracement-Levels und garantiert, dass die Proportionen der einzelnen Strecken den tatsächlichen Marktschwankungen entsprechen. Nach Abschluss dieser Rekalibrierung prüft die Software, ob jeder Punkt des steigenden 5-0-Musters noch die richtige Reihenfolge und Verknüpfung aufweist. Die Methode prüft, ob sich eine legitime 5-0-Struktur auf dem Chart entwickelt hat, sobald alle geometrischen und Fibonacci-Anforderungen erfüllt sind.

Ausführung des Handels

Nachdem bestätigt wurde, dass das steigende 5-0 harmonische Muster korrekt identifiziert wurde, besteht der nächste Schritt darin, auf der Grundlage dieser Struktur zu handeln. Bei diesem Setup erfolgt der Einstieg in den Handel, wenn der Kurs den Punkt D erreicht, der die potenzielle Vollendung des Musters und eine mögliche Aufwärts-Umkehr darstellt. In MQL5 kann dies implementiert werden, indem geprüft wird, ob der aktuelle Preis um den Punkt D liegt, und dann ein Kaufauftrag mit vordefinierten Parametern wie Losgröße, Stop Loss und Take Profit eröffnet wird.

Beispiel:

#include <Trade/Trade.mqh>
CTrade trade;
input double lot_size = 0.6;

datetime time_price[];
double ask_price;
double take_p;
datetime last_trade_time = 0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

   ArraySetAsSeries(time_price,true);

//---
   return(INIT_SUCCEEDED);
  }

CopyTime(_Symbol, timeframe, 0, 2, time_price);
ask_price = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
datetime current_bar_time = iTime(_Symbol,timeframe,0);

if(x_a_ll < o_x_hh && a_b_hh > x_a_ll && a_b_hh < o_x_hh && b_c_ll <= fib_ext_b_113 && b_c_ll >= fib_ext_b_161 && c_d_hh >= fib_ext_c_161 && c_d_hh <= fib_ext_c_224 && D <= fib_ret_d_50 && D >= fib_ret_d_55)
  {

   ObjectCreate(chart_id,O_letter,OBJ_TEXT,0,o_x_hh_t,o_x_hh);
   ObjectSetString(chart_id,O_letter,OBJPROP_TEXT,"0");
   ObjectSetInteger(chart_id,O_letter,OBJPROP_COLOR,clrBlue);

   ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,x_a_ll_t,x_a_ll);
   ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X");
   ObjectSetInteger(chart_id,X_letter,OBJPROP_COLOR,clrBlue);

   ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,a_b_hh_t,a_b_hh);
   ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A");
   ObjectSetInteger(chart_id,A_letter,OBJPROP_COLOR,clrBlue);

   ObjectCreate(chart_id,B_letter,OBJ_TEXT,0,b_c_ll_t,b_c_ll);
   ObjectSetString(chart_id,B_letter,OBJPROP_TEXT,"B");
   ObjectSetInteger(chart_id,B_letter,OBJPROP_COLOR,clrBlue);

   ox_line = StringFormat("0X Line  %d",i);
   xa_line = StringFormat("XA Line  %d",i);
   ab_line = StringFormat("AB Line  %d",i);

   ObjectCreate(chart_id,ox_line,OBJ_TREND,0, o_x_hh_t, o_x_hh,x_a_ll_t,x_a_ll);
   ObjectSetInteger(chart_id,ox_line,OBJPROP_COLOR,clrBlue);

   ObjectCreate(chart_id,xa_line,OBJ_TREND,0, x_a_ll_t, x_a_ll,a_b_hh_t,a_b_hh);
   ObjectSetInteger(chart_id,xa_line,OBJPROP_COLOR,clrBlue);

   ObjectCreate(chart_id,ab_line,OBJ_TREND,0, a_b_hh_t, a_b_hh,b_c_ll_t,b_c_ll);
   ObjectSetInteger(chart_id,ab_line,OBJPROP_COLOR,clrBlue);

   fib_xa_ext_obj = StringFormat("XA Expansion  %d",i);
   ObjectCreate(chart_id,fib_xa_ext_obj,OBJ_EXPANSION,0,a_b_hh_t,a_b_hh,x_a_ll_t,x_a_ll,a_b_hh_t,a_b_hh);
   ObjectSetInteger(chart_id,fib_xa_ext_obj,OBJPROP_COLOR,clrBlue);
   for(int i = 0; i <= 2; i++)
     {
      ObjectSetInteger(chart_id,fib_xa_ext_obj,OBJPROP_LEVELCOLOR,i,clrBlue);
     }

   fib_xa_ext_lvl = StringFormat("XA Expansion Levels %d",i);

   ObjectCreate(chart_id,fib_xa_ext_lvl,OBJ_RECTANGLE,0,x_a_ll_t,fib_ext_b_113,b_c_ll_t,fib_ext_b_161);
   ObjectSetInteger(chart_id,fib_xa_ext_lvl,OBJPROP_COLOR,clrBlue);

   ObjectCreate(chart_id,C_letter,OBJ_TEXT,0,c_d_hh_t,c_d_hh);
   ObjectSetString(chart_id,C_letter,OBJPROP_TEXT,"C");
   ObjectSetInteger(chart_id,C_letter,OBJPROP_COLOR,clrBlue);

   bc_line = StringFormat("BC Line  %d",i);
   ObjectCreate(chart_id,bc_line,OBJ_TREND,0, b_c_ll_t, b_c_ll,c_d_hh_t,c_d_hh);
   ObjectSetInteger(chart_id,bc_line,OBJPROP_COLOR,clrBlue);

   fib_ab_ext_obj = StringFormat("AB Expansion  %d",i);
   ObjectCreate(chart_id,fib_ab_ext_obj,OBJ_EXPANSION,0,b_c_ll_t,b_c_ll,a_b_hh_t,a_b_hh,b_c_ll_t,b_c_ll);
   ObjectSetInteger(chart_id,fib_ab_ext_obj,OBJPROP_COLOR,clrBlue);
   for(int i = 0; i <= 2; i++)
     {
      ObjectSetInteger(chart_id,fib_ab_ext_obj,OBJPROP_LEVELCOLOR,i,clrBlue);
     }

   fib_ab_ext_lvl = StringFormat("AB Expansion Levels %d",i);

   ObjectCreate(chart_id,fib_ab_ext_lvl,OBJ_RECTANGLE,0,a_b_hh_t,fib_ext_c_161,c_d_hh_t,fib_ext_c_224);
   ObjectSetInteger(chart_id,fib_ab_ext_lvl,OBJPROP_COLOR,clrBlue);

   ObjectCreate(chart_id,D_letter,OBJ_TEXT,0,D_time,D);
   ObjectSetString(chart_id,D_letter,OBJPROP_TEXT,"D");
   ObjectSetInteger(chart_id,D_letter,OBJPROP_COLOR,clrBlue);

   cd_line = StringFormat("CD Line  %d",i);
   ObjectCreate(chart_id,cd_line,OBJ_TREND,0, c_d_hh_t, c_d_hh,D_time,D);
   ObjectSetInteger(chart_id,cd_line,OBJPROP_COLOR,clrBlue);

   fib_bc_ret_lvl = StringFormat("BC RETRACEMENT Levels %d",i);

   ObjectCreate(chart_id,fib_bc_ret_lvl,OBJ_RECTANGLE,0,b_c_ll_t,fib_ret_d_50,D_time,fib_ret_d_55);
   ObjectSetInteger(chart_id,fib_bc_ret_lvl,OBJPROP_COLOR,clrBlue);

   if(time[n+z] == time_price[1] && close[n+z] > D && current_bar_time != last_trade_time)
     {
      take_p = ask_price + (MathAbs(ask_price - D) * 3);

      trade.Buy(lot_size,_Symbol,ask_price,D,take_p);

      last_trade_time = current_bar_time;

     }
  }

Ausgabe:

Erläuterung:

Nach der Bestätigung des steigenden harmonischen 5-0-Musters wird der Handel von diesem Teil der Software ausgeführt. Die MQL5-Handelsbibliothek, die die CTrade-Klasse liefert, die für die Übermittlung von Handelsaufträgen an den Broker benötigt wird, wird in der ersten Zeile #include <Trade/Trade.mqh> importiert. Nachdem eine Instanz dieser Klasse erstellt wurde, ermöglicht die Zeile CTrade trade; dem Programm, Handelsoperationen wie Kauf und Verkauf durchzuführen. Für jedes eröffnete Handelsgeschäft werden 0,6 Lots verwendet, wie durch die Eingabevariable lot_size = 0,6 definiert.

Um die Handelsausführung zu kontrollieren und doppelte Eingaben zu vermeiden, definiert das Programm eine Reihe von Variablen. Ask_price speichert den aktuellen Briefkurs, take_p wird verwendet, um das Take-Profit-Ziel zu bestimmen, last_trade_time protokolliert den Zeitpunkt des letzten Handels und das Array time_price[] verfolgt die Kerzenzeiten. Um sich an die Handhabung von Zeitreihendaten in MQL5 anzupassen, wird das time_price-Array in der Reihenfolge vom neuesten zum ältesten initialisiert. Die Software ruft die letzten Kerzenzeiten und Marktpreise für jeden Tick ab.

Die aktuelle Kerzenzeit muss mit der zuletzt kopierten Zeit übereinstimmen, der Schlusskurs muss über dem Punkt D liegen, und es darf kein Handel auf derselben Kerze ausgeführt worden sein. Diese Kriterien werden dann überprüft, um festzustellen, ob ein Handel eröffnet werden sollte. Um Mehrfacheingaben innerhalb desselben Balkens zu vermeiden, führt der Computer eine Kauftransaktion durch, wenn diese Voraussetzungen erfüllt sind, legt ein Take-Profit-Ziel fest, das dreimal so groß ist wie der Abstand zwischen dem aktuellen Briefkurs und Punkt D, und protokolliert die Handelszeit.

Schlussfolgerung

In diesem Artikel wurde erklärt, wie man einen Expert Advisor erstellt, der das harmonische Muster 5-0 erkennt und handelt. Es wurde behandelt, wie man jeden Umkehrpunkt identifiziert und validiert, die Struktur des Musters bestätigt, Handelsgeschäfte automatisch ausführt und das Muster auf dem Chart mit Hilfe von grafischen Objekten wie Trendlinien und Kennzeichnungen anzeigt. Dies ist der letzte Teil der Serie über die fortgeschrittenen Chart-Muster. Im nächsten Teil werden neue Aspekte von MQL5 erkundet.