Wie man mit MQL5 Trends und Chartmuster erkennt
568
0
Einführung
Als Händler haben wir alle mit Charts zu tun und versuchen, sie richtig zu lesen, um verschiedene Szenarien zu verstehen, die in der Kursentwicklung auftreten können, um die richtige Entscheidung zu treffen. Denn das Chart enthält viele Muster, die auftreten können und die hilfreich sind, um eine mögliche Kursbewegung vorherzusagen, wenn wir sie erkennen. Wenn wir also über nützliche Instrumente verfügen, die uns dabei helfen können, dies einfach und genau zu tun, dann ist das meiner Meinung nach eine gute Sache. In diesem Artikel werde ich versuchen, einige hilfreiche Werkzeuge zu entwickeln, um die Muster zu erkennen, die durch Preis-Aktionen gebildet werden, und den Trendtyp anzeigen.
Wir werden dies anhand der folgenden Themen behandeln:
- Erkennen von Hochs und Tiefs
- Erkennen von Trends
- Erkennen von Doppelspitzen im Chart
- Erkennen von Doppelböden im Chart
- Schlussfolgerung
Nach der Lektüre dieses Artikels werden Sie in der Lage sein, Hochs und Tiefs zu erkennen, Trendtypen zu identifizieren und Doppelspitzen und Doppelböden zu erkennen. Sie müssen also versuchen, die genannten Codes selbst zu schreiben, und Sie müssen testen und entwickeln, was Sie brauchen, um bessere Einblicke und Ergebnisse zu erhalten, bevor Sie es für Ihr echtes Konto verwenden. Das Hauptziel dieses Artikels ist es, die Hauptidee des Erkennens von Hochs und Tiefs und Chart-Muster zu verstehen, um Ihren Code mehr und mehr zu entwickeln, um zu erkennen, was Sie von bekannten oder unbekannten signifikanten Mustern benötigen, da es viele aussagekräftige Muster gibt, die auf dem Chart zu sehen sind. Das kann bahnbrechend für Ihren Handel sein, wenn Sie verstehen, wie Sie davon profitieren können.
Wir werden in diesem Artikel die MQL5 (MetaQuotes Language) IDE verwenden, die in das MetaTrader 5-Handelsterminal integriert ist. Wenn Sie nicht wissen, wie man MQL5 verwendet und Sie lernen wollen, wie man den MetaTrader 5 herunterlädt und MQL5 zum Schreiben von Codes verwendet, können Sie das Thema Schreiben von MQL5-Code in MetaEditor aus meinem vorherigen Artikel lesen.
Erkennung der Hochs und Tiefs
In diesem Teil beginnen wir mit dem Erkennen von Hochs und Tiefs auf dem Chart durch MQL5 und verwenden dies als Basis, um unsere Bedingungen für jedes Chartmuster zu deklarieren. Erstens, wie wir alle wissen, sind Hochs und Tiefs wie folgt definiert:
Hochs:
Hoch bedeutet, dass es aufgrund der Stärke der Käufer eine Aufwärtsbewegung bis zu einem bestimmten Niveau gab und dann der Verkäufer auftaucht und den Preis von diesem hohen Niveau aus nach unten drückt. Die folgende Abbildung ist ein Beispiel.
Tiefs:
Ein Tief bedeutet, dass eine Abwärtsbewegung bis zu einem bestimmten Niveau stattgefunden hat, weil die Verkäufer zu stark waren und dann die Käufer auftauchte und den Preis von diesem niedrigen Niveau aus nach oben drückte. Die folgende Abbildung ist ein Beispiel.
Nachdem wir diese beiden wichtigen Preisniveaus identifiziert haben, müssen wir ein MQL5-Programm oder einen Expert Advisor erstellen, der diese Arten von Bewegungen erkennen kann. Es gibt viele Methoden, die dafür verwendet werden können, und wir werden eine dieser Methoden in den folgenden Zeilen vorstellen.
Wir müssen bestimmte Preisniveaus bestimmen (Hoch und Tief), dann gehen wir zu anderen bestimmten Preisniveaus (Hoch und Tief) und vergleichen Hoch mit Hoch und Tief mit Tief, um festzustellen, ob wir ein weiteres Hoch oder Tief haben. Um dies zu tun, müssen wir bestimmte Schritte wie die folgenden durchführen.
Wir erstellen eine Funktion für OnTick(), die das Hoch oder Tief ermittelt. Sie heißt (getNextMove), die eine ganze Zahl zurückgibt und folgende Parameter hat:
- int move: um festzustellen, ob es ein Hoch oder Tief ist.
- int count: zur Bestimmung der Anzahl in Bezug auf die Variable startPos.
- int startPos: um die Startposition zu bestimmen, von der aus wir beginnen wollen.
int getNextMove(int move, int count, int startPos)
Innerhalb dieser Funktion müssen wir die folgende Prüfung durchführen, indem wir die if-Anweisung verwenden, um den Wert der Funktionsparameter zu identifizieren. Wir müssen prüfen, ob (startPos) kleiner als Null ist, wir müssen den Wert von startPos zur Anzahl hinzufügen und startPos mit dem Wert Null aktualisieren, um mit der aktuellen Bar zu beginnen.
if(startPos<0) { count +=startPos; startPos =0; }
Jetzt haben wir die Variablen (count) und (startPos) in der Funktion identifiziert. Die (move)-Variable wird im zurückgegebenen Wert identifiziert, indem der Return-Operator verwendet wird, der die Funktionsausführung beendet und den Wert von move zurückgibt, und indem der ternäre Operator (?:) verwendet wird, der aus drei Ausdrücken besteht, wobei der erste vom Typ bool ist und, wenn er wahr ist, der zweite Ausdruck ausgeführt wird und, wenn er falsch ist, der dritte Ausdruck ausgeführt wird.
Wir geben also im ersten Operator an, ob die Variable move gleich dem Hoch ist. Wenn dies der Fall ist, wird der Wert vom Hoch (High) zurückgegeben, wenn dies falsch ist, wird der Wert vom Tief (Low) zurückgegeben.
Um zu prüfen, ob die Bewegung steigt, verwenden wir die MODE_HIGH-Funktionen, die eine der Zeitreihenkennungen sind, die in den iHighest()- und iLowest()-Funktionen verwendet werden, um den höchsten Preis zurückzugeben. Für die Parameter der Funktionen iHighest und iLowest, die den Index des höchsten und niedrigsten Wertes zurückgeben sollen, gilt Folgendes:
- symbol: Wir verwenden Symbol(), um den aktuellen Symbolnamen als konstante Zeichenkette zurückzugeben.
- timeframe: Wir werden Period() verwenden, um den aktuellen Zeitrahmen als ENUM_TIMEFRAMES zurückzugeben.
- type: Wir verwenden (ENUM_SERIESMODE) move, um die Art der Bewegung als Zeitreihenkennzeichen zurückzugeben. Bei diesem Typ wird der höchste Wert für den iHighest und der niedrigste Wert für den iLowest angegeben.
- count: Wir verwenden die Integer-Variable (count), um die Anzahl der Elemente zurückzugeben.
- start: Wir verwenden die Integer-Variable (startPos), um den Index zurückzugeben.
return((move==MODE_HIGH)? iHighest(Symbol(),Period(),(ENUM_SERIESMODE)move,count,startPos): iLowest(Symbol(),Period(),(ENUM_SERIESMODE)move,count,startPos));
Nachdem wir diese Funktion erstellt haben, die die nächste Bewegung zurückgibt, erstellen wir eine weitere Integer-Funktion, die die Hauptfunktion sein wird, um das Hoch oder Tief der aktuellen Bewegung zu erhalten. Sein Name ist (getmove) mit drei ganzzahligen Variablen als Parameter (move, count und startPos)
int getmove(int move, int count, int startPos)
Innerhalb dieser Funktion müssen wir prüfen, ob die Bewegung nicht dem MODE_HIGH oder MODE_LOW entspricht. Der zurückgegebene Wert ist (-1).
if(move!=MODE_HIGH && move!=MODE_LOW) return (-1);
Erstellen einer neuen Integer-Variablen (currentBar), der (startPos) zugewiesen wird.
int currentBar=startPos; Erstellen einer neuen Integer-Variablen (moveReturned), der das Ergebnis der erstellten Funktion getNextMove mit den folgenden Parametern (move, (count*2+1), currentBar-count)) zugewiesen wird.
int moveReturned=getNextMove(move,count*2+1,currentBar-count);
Wir erstellen eine while-Schleife, um einen Ausdruck zu überprüfen, und wenn dieser wahr ist, wird der Operator ausgeführt. Hier ist der Ausdruck, den wir überprüfen müssen, ob moveReturned nicht gleich dem currentBar ist, und wenn dies der Fall ist, müssen die folgenden Operatoren ausgeführt werden:
- Aktualisierung der Variablen (currentBar) mit getNextMove mit den Parametern (move, count,currentBar+1).
- Aktualisierung der Variablen (moveReturned) mit getNextMove mit den Parametern (move,count*2+1,currentBar-count).
while(moveReturned!=currentBar) { currentBar=getNextMove(move,count,currentBar+1); moveReturned=getNextMove(move,count*2+1,currentBar-count); }
Wir verwenden dann die Return-Funktion, um die Funktion zu beenden und den Wert von currentBar zurückzugeben
return(currentBar); Dann werden wir innerhalb von OnTick() die Funktion aufrufen, um Hochs und Tiefs zu erkennen. Zuerst mit den drei Integer-Variablen:
int checkBars= 5; int move1; int move2;
Aktualisierung von move1 und move2 mit unserer zuvor erstellten Funktion getmove mit den Parametern (MODE_HIGH,checkBars,0) für move1 und (MODE_HIGH,checkBars,move1+1) für move2, um die beiden Hochs zu erkennen
move1=getmove(MODE_HIGH,checkBars,0); move2=getmove(MODE_HIGH,checkBars,move1+1);
Wir erstellen mit den folgenden Schritten ein Linienobjekt über diesen beiden Hochpunkten:
Wir löschen eine vorhandene Linie mit Hilfe der Funktion (ObjectDelete), die ein Objekt mit einem Namen entfernt. Für diese Funktion gibt es mehrere Parameter. Der erste ist chart_id, um die Kennung des Charts zu bestimmen, und wir werden 0 für das aktuelle Chart verwenden. Der zweite Parameter ist der Name, um den Objektnamen zu bestimmen, verwenden wir topLine als String.
ObjectDelete(0,"topLine");
Erstellen eines neuen topLine-Objekts mit Hilfe der Funktion ObjectCreate, die ein Objekt mit einem neuen Namen erstellt. Die Parameter sind:
- chart_id: Wir verwenden (0), um die ID des aktuellen Charts (vom Typ long) zurückzugeben.
- name: Wir verwenden „topLine“, um einen String-Typ als Namen des Objekts zurückzugeben.
- type: Wir verwenden OBJ_TREND, um einen ENUM_OBJECT-Typ oder den Objekttyp zurückzugeben.
- nwin: Wir verwenden (0) für das aktuelle Chart als Fensterindex.
- time1: Um die Zeit des move2-Ankers zu bestimmen und den Datentyp datetime zurückzugeben, verwenden wir iTime(Symbol(),Period(),move2)
- price1: Um den Preis des Ankers move2 zu bestimmen und den Typ double zurückzugeben, verwenden wir iHigh(Symbol(),Period(),move2).
- timeN=0: Um die Zeit des Ankers move1 zu bestimmen und den Datentyp datetime zurückzugeben, wird iTime(Symbol(),Period(),move1) verwendet.
- priceN=0: Um den Preis des Ankers move1 zu bestimmen und den Typ double zurückzugeben, verwenden wir iHigh(Symbol(),Period(),move1).
Wie wir sehen können, gibt die Funktion iHigh den Höchstkurs des Balkens zurück und ihre Parameter sind Symbol, Zeitrahmen und Verschiebung. Die Funktion iTime gibt die Eröffnungszeit des Balkens zurück und ihre Parameter sind die gleichen wie die der Funktion iHigh.
ObjectCreate(0,"topLine",OBJ_TREND,0,iTime(Symbol(),Period(),move2),iHigh(Symbol(),Period(),move2),iTime(Symbol(),Period(),move1),iHigh(Symbol(),Period(),move1));
Einstellen von Farbe, Breite und Linientyp für dieses erstellte Objekt mit der Funktion ObjectSetInteger. Die Parameter sind:
- chart_id: um die Kennung des Charts zu bestimmen; sie wird (0) sein.
- name: für den Objektnamen, z. B. „TopLine“ für die Hochs.
- prop_id: um die Objekteigenschaft zu bestimmen, wird OBJPROP_COLOR für die Farbe, OBJPROP_WIDTH für die Breite und OBJPROP_RAY_RIGHT für die Art der Linie verwendet.
- prop_value: Um den gewünschten Wert zu bestimmen, wird für die Farbe clrRed, für die Breite 3 und für den Linientyp true verwendet.
ObjectSetInteger(0,"topLine",OBJPROP_COLOR,clrRed); ObjectSetInteger(0,"topLine",OBJPROP_WIDTH,3); ObjectSetInteger(0,"topLine",OBJPROP_RAY_RIGHT,true);
Die beiden Tiefs werden durch Aktualisierung der Variablen move1 und move2 auf die gleiche Weise wie bei den Hochs ermittelt, wobei der Modus MODE_LOW als Zeitreihenkennzeichen verwendet wird.
move1=getmove(MODE_LOW,checkBars,0); move2=getmove(MODE_LOW,checkBars,move1+1);
Das Löschen und Erstellen des Linienobjekts unter diesen beiden Tiefs erfolgt auf die gleiche Weise wie bei den Hochs, mit Unterschieden im Namen des Objekts, der „bottomLine“ lautet, und in der grünen Farbe.
ObjectDelete(0,"bottomLine"); ObjectCreate(0,"bottomLine",OBJ_TREND,0,iTime(Symbol(),Period(),move2),iLow(Symbol(),Period(),move2),iTime(Symbol(),Period(),move1),iLow(Symbol(),Period(),move1)); ObjectSetInteger(0,"bottomLine",OBJPROP_COLOR,clrGreen); ObjectSetInteger(0,"bottomLine",OBJPROP_WIDTH,3); ObjectSetInteger(0,"bottomLine",OBJPROP_RAY_RIGHT,true);
Im Folgenden wird der gesamte Code in einem Block dargestellt:
//+------------------------------------------------------------------+ //| moveFinder.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { int checkBars= 5; int move1; int move2; move1=getmove(MODE_HIGH,checkBars,0); move2=getmove(MODE_HIGH,checkBars,move1+1); ObjectDelete(0,"topLine"); ObjectCreate(0,"topLine",OBJ_TREND,0,iTime(Symbol(),Period(),move2),iHigh(Symbol(),Period(),move2),iTime(Symbol(),Period(),move1),iHigh(Symbol(),Period(),move1)); ObjectSetInteger(0,"topLine",OBJPROP_COLOR,clrRed); ObjectSetInteger(0,"topLine",OBJPROP_WIDTH,3); ObjectSetInteger(0,"topLine",OBJPROP_RAY_RIGHT,true); move1=getmove(MODE_LOW,checkBars,0); move2=getmove(MODE_LOW,checkBars,move1+1); ObjectDelete(0,"bottomLine"); ObjectCreate(0,"bottomLine",OBJ_TREND,0,iTime(Symbol(),Period(),move2),iLow(Symbol(),Period(),move2),iTime(Symbol(),Period(),move1),iLow(Symbol(),Period(),move1)); ObjectSetInteger(0,"bottomLine",OBJPROP_COLOR,clrGreen); ObjectSetInteger(0,"bottomLine",OBJPROP_WIDTH,3); ObjectSetInteger(0,"bottomLine",OBJPROP_RAY_RIGHT,true); } int getmove(int move, int count, int startPos) { if(move!=MODE_HIGH && move!=MODE_LOW) return (-1); int currentBar=startPos; int moveReturned=getNextMove(move,count*2+1,currentBar-count); while(moveReturned!=currentBar) { currentBar=getNextMove(move,count,currentBar+1); moveReturned=getNextMove(move,count*2+1,currentBar-count); } return(currentBar); } int getNextMove(int move, int count, int startPos) { if(startPos<0) { count +=startPos; startPos =0; } return((move==MODE_HIGH)? iHighest(Symbol(),Period(),(ENUM_SERIESMODE)move,count,startPos): iLowest(Symbol(),Period(),(ENUM_SERIESMODE)move,count,startPos)); }
Nach dem fehlerfreien Kompilieren und Ausführen dieses Codes können wir zwei Linien auf dem Chart erhalten, um zwei Hochs mit einer roten Linie darüber und zwei Tiefs mit einer grünen Linie darunter zu erkennen. Nachfolgend finden Sie Beispiele aus der Testphase:
Wie wir im vorherigen Beispiel sehen können, können diese beiden Linien ein Muster auf dem Chart zeigen, um die Bewegung des Preises anzuzeigen. Wir können im vorherigen Beispiel sehen, dass wir eine starke Aufwärtsbewegung haben, da wir zwei Aufwärtslinien haben und der Winkel der oberen Linie breiter ist als die untere. Sie können also ein sehr nützliches Instrument zur Interpretation der Kursentwicklung sein.
Es folgt ein weiteres Beispiel mit einem anderen Muster entsprechend einer anderen Preisaktion:
Hier ist eine andere Preisaktion zu sehen. Jetzt bewegt sich die obere Linie nach unten und die untere steigt. Das deutet darauf hin, dass es ein Gleichgewicht zwischen Käufern und Verkäufern gibt, indem weder die Käufer noch die Verkäufer die Preise jeweils in ihre Richtung treiben können.
Nachfolgend ein Beispiel für ein weiteres Muster der Preisaktion:
Wie wir im vorherigen Chart sehen können, haben wir ein anderes Chart-Muster, da wir zwei parallele Abwärtslinien haben, die die Stärke der Verkäufer anzeigen können, da sie in der Lage sind, die Preise nach unten zu drücken.
Erkennen von Trends
Nachdem wir im vorigen Teil gelernt haben, wie wir Hochs und Tiefs im Chart erkennen können, können wir diesen Code entwickeln, um Trends im Chart zu erkennen, denn wir haben zwei Hochs und zwei Tiefs erkannt, und das ist es, was wir brauchen, um den Trend zu erkennen. In diesem Teil des Artikels geht es darum, unseren vorherigen Code weiterzuentwickeln, um Trends im Chart in seinen drei Typen so weit wie möglich zu erkennen, wobei der vorherige Code einige Unterschiede aufweist.
Trends sind einfach die Bewegung der Preis-Aktion und diese Bewegung strebt nach oben, nach unten, oder ohne klare Richtung weder nach oben noch nach unten. Das sind dann die drei Arten von Trends:
Aufwärtstrend:
Diese Art der Preisbewegung führt dazu, dass sich die Preise weiter nach oben bewegen und höhere Preise erzielen, da die Käufer bei dieser Art der Preisbewegung die starke Partei auf dem Markt sind. So können wir auf dem Chart feststellen, dass der Kurs eindeutig höhere Tiefs und höhere Hochs bildet. Die folgende Abbildung ist ein Chart für diesen Typ:
Abwärtstrend:
So ein Trend ist das Gegenteil eines Aufwärtstrends, da bei einem Abwärtstrend die Verkäufer stärker sind als die Käufer und die Preise nach unten drücken und so niedrigere Preis erzielen. Wir können also auf dem Chart sehen, dass die Preise niedrigere Hochs und Tiefs bilden.
Das folgende Chart zeigt es:
Seitwärts:
Bei diesem Typ gibt es keine Kursbewegung, die als Auf- oder Abwärtstrend bezeichnet werden kann. Dieser Typ ist also weder ein Aufwärts- noch ein Abwärtstrend und er hat viele Formen und die folgenden Muster sind einige dieser Formen:
Jetzt müssen wir einen MQL5 EA erstellen, der erkennen kann, ob wir einen Trend haben (aufwärts oder abwärts) oder ob wir keinen Trend haben (seitwärts). Der folgende Code dient der Erstellung dieser Art von EA:
//+------------------------------------------------------------------+ //| trendFinder.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { int checkBars= 5; int high1, high2, low1, low2; double highVal1, highVal2, lowVal1, lowVal2; high1=getmove(MODE_HIGH,checkBars,0); high2=getmove(MODE_HIGH,checkBars,high1+1); highVal1=NormalizeDouble(iHigh(_Symbol,_Period,high1),5); highVal2=NormalizeDouble(iHigh(_Symbol,_Period,high2),5); ObjectDelete(0,"topLine"); ObjectCreate(0,"topLine",OBJ_TREND,0,iTime(Symbol(),Period(),high2),iHigh(Symbol(),Period(),high2),iTime(Symbol(),Period(),high1),iHigh(Symbol(),Period(),high1)); ObjectSetInteger(0,"topLine",OBJPROP_COLOR,clrRed); ObjectSetInteger(0,"topLine",OBJPROP_WIDTH,3); ObjectSetInteger(0,"topLine",OBJPROP_RAY_RIGHT,true); low1=getmove(MODE_LOW,checkBars,0); low2=getmove(MODE_LOW,checkBars,low1+1); lowVal1=NormalizeDouble(iLow(_Symbol,_Period,low1),5); lowVal2=NormalizeDouble(iLow(_Symbol,_Period,low2),5); ObjectDelete(0,"bottomLine"); ObjectCreate(0,"bottomLine",OBJ_TREND,0,iTime(Symbol(),Period(),low2),iLow(Symbol(),Period(),low2),iTime(Symbol(),Period(),low1),iLow(Symbol(),Period(),low1)); ObjectSetInteger(0,"bottomLine",OBJPROP_COLOR,clrGreen); ObjectSetInteger(0,"bottomLine",OBJPROP_WIDTH,3); ObjectSetInteger(0,"bottomLine",OBJPROP_RAY_RIGHT,true); if(lowVal1>lowVal2&&highVal1>highVal2) { Comment("Uptrend", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); } else if(highVal1<highVal2&&lowVal1<lowVal2) { Comment("Downtrend", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); } else { Comment("Sideways", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); } } int getmove(int move, int count, int startPos) { if(move!=MODE_HIGH && move!=MODE_LOW) return (-1); int currentBar=startPos; int moveReturned=getNextMove(move,count*2+1,currentBar-count); while(moveReturned!=currentBar) { currentBar=getNextMove(move,count,currentBar+1); moveReturned=getNextMove(move,count*2+1,currentBar-count); } return(currentBar); } int getNextMove(int move, int count, int startPos) { if(startPos<0) { count +=startPos; startPos =0; } return((move==MODE_HIGH)? iHighest(Symbol(),Period(),(ENUM_SERIESMODE)move,count,startPos): iLowest(Symbol(),Period(),(ENUM_SERIESMODE)move,count,startPos)); }
Es gibt folgende Unterschiede in diesem Code, um Trends zu erkennen.
Erstellen von vier Integer-Variablen für zwei Höchst- und zwei Tiefstwerte und weiteren vier Double-Variablen für zwei Höchst- und zwei Tiefstwerte innerhalb des Bereichs der OnTick-Funktion:
int high1, high2, low1, low2; double highVal1, highVal2, lowVal1, lowVal2;
Aktualisierung der beiden Hochs (highVal1, highVal2) durch Verwendung der Funktion NormalizeDouble, um das Ergebnis eines Hochs zu runden, und ihre Parameter sind:
- Wert: die Zahl, die wir brauchen, um zu normalisieren, werden wir die Funktion iHigh verwenden, um den hohen Preis und seine Parameter sind das Symbol, das (_Symbol) für die aktuelle sein wird, Zeitrahmen, die (_Period) für den aktuellen Zeitrahmen sein wird, und Verschiebung für den Index, die high1 und high2 sein wird.
- Ziffern: die Anzahl der Stellen nach dem Dezimalpunkt, wird 5 sein.
highVal1=NormalizeDouble(iHigh(_Symbol,_Period,high1),5); highVal2=NormalizeDouble(iHigh(_Symbol,_Period,high2),5);
Aktualisierung der beiden Tiefs (lowVal1, lowVal2) durch Verwendung der Funktion NormalizeDouble mit denselben Parametern, die wir zuvor genannt haben, mit den folgenden Unterschieden:
- value: Wir verwenden die Funktion iLow, um den niedrigen Preis zurückzugeben. Die Parameter sind die gleichen, außer der Verschiebung des Indexes, der low1 und low sein wird.
lowVal1=NormalizeDouble(iLow(_Symbol,_Period,low1),5); lowVal2=NormalizeDouble(iLow(_Symbol,_Period,low2),5);
Bedingungen, die wir brauchen, um Trends zu identifizieren, und wir werden die if-Anweisung verwenden, müssen wir die EA überprüfen vier Werte von Hochs und Tiefs kontinuierlich dann entscheiden, ihre Positionen im Verhältnis zueinander dann entscheiden, ob wir einen Trend (auf- oder abwärts) oder wir haben keinen Trend (seitwärts).
Bedingungen des Aufwärtstrends:
Wenn lowVal1 größer ist als lowVal2 und gleichzeitig highVal1 größer ist als highVal2, haben wir einen Aufwärtstrend und der EA soll einen Kommentar auf dem Chart wie folgt ausgeben:
- Uptrend
- Current High
- Previous High
- Current Low
- Previous Low
if(lowVal1>lowVal2&&highVal1>highVal2) { Comment("Uptrend", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); }
Bedingungen des Abwärtstrends:
Wenn highVal1 niedriger ist als highVal2 und gleichzeitig lowVal1 niedriger ist als lowVal2, haben wir einen Abwärtstrend und der EA soll einen Kommentar auf dem Chart wie folgt ausgeben:
- Downtrend
- Current High
- Previous High
- Current Low
- Previous Low
else if(highVal1<highVal2&&lowVal1<lowVal2) { Comment("Downtrend", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); }
Bedingungen der Seitwärtsbewegung:
Wenn die Positionen der vier Werte etwas anderes sind als die Bedingungen des Aufwärts- und Abwärtstrends, haben wir eine Seitwärtsbewegung und wir brauchen den EA und der EA soll einen Kommentar auf dem Chart wie folgt ausgeben:
else { Comment("Sideways", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); }
Nachdem wir diesen Code mit Fehlern kompiliert und seinen EA ausgeführt haben, können wir Signale von Trends erhalten, wie wir sie brauchen. Nachfolgend finden Sie Beispiele für Tests je nach Trendtyp und Bedingung.
Aufwärtstrend:
In der vorangegangenen Abbildung sehen wir, dass es sich um ein Beispiel für einen Aufwärtstrend handelt, da wir ein höheres Tief und ein höheres Hoch in der Preisbewegung dieses Charts haben. Wir werden also ein Aufwärtssignal als Kommentar in der oberen linken Ecke des Charts erhalten.
Abwärtstrend:
Wie wir im vorherigen Chart deutlich sehen können, befinden wir uns in einem Abwärtstrend, da wir ein niedrigeres Hoch und ein niedrigeres Tief in der Preisbewegung haben. Wir sehen also ein Abwärtstrendsignal als Kommentar auf dem Chart.
Seitwärts:
Wie wir im vorherigen Beispiel sehen können, haben wir eine Form, die sich von Aufwärts- und Abwärtstrend unterscheidet, und wir haben ein niedrigeres Hoch und ein höheres Tief, was eine Seitwärtsbewegung darstellt. Wir sehen also ein Seitwärtssignal als Kommentar auf dem Chart.
Erkennen von Doppelspitzen im Chart
Nachdem wir gelernt hatten, wie man Hochs und Tiefs erkennt, konnten wir darauf aufbauend Trends erkennen, wobei der Basiscode für das Erkennen von Hochs und Tiefs weiterentwickelt wurde. Wenn wir also der Meinung sind, dass wir im Code mehr entwickeln können, um zu versuchen, bestimmte Chart- oder Preisaktionsmuster zu erkennen, die auf eine potenzielle Bewegung hindeuten könnten.
In diesem Teil werde ich das Erkennen dieser Chart-Muster durch eine kleine Erweiterung des Codes ermöglichen. Diese wichtige Idee kann mehr signifikante Muster erkennen vor allem, wenn Sie einige nützliche technische Werkzeuge in Ihrem Code verschmelzen. In diesem Teil des Artikels werden wir eines der beliebten Chartmuster sehen, das auf dem Chart zu sehen ist: Doppelspitzen (engl. Double Tops).
Doppelspitzen sind ein Chart-Muster, das wir auf dem Chart sehen können und bestehen aus gleich hohen Hochs, die darauf hinweisen, dass es eine Schwäche in der Kaufkraft und es ein Potenzial gibt, dass die Preise nach unten bewegen. Das folgende Chart ist ein visuelles Beispiel für eine potenzielle Doppelspitze:
Wenn Sie bemerkt haben, dass wir im vorherigen Beispiel erwähnt haben, dass es sich um ein potenzielles Muster handelt, wird es ein konformes Muster sein, wenn die Preise brechen und unter dem Tief zwischen den beiden Hochs schließen, wie in der folgenden Grafik:
Nun müssen wir einen MQL5 EA erstellen, der zur Erkennung dieser beiden Muster im MetaTrader 5 verwendet werden kann. Wir brauchen den EA, um die beiden Hochs und die beiden Tiefs kontinuierlich zu überprüfen und ihre Positionen zueinander zu bestimmen und dann ein bestimmtes Ergebnis auf der Grundlage einer bestimmten Bedingung zurückzugeben, die die Bedingung der Doppelspitzen ausweisen. Hier ist der Code, der potentielle hohe und tiefe Doppelspitzen erkennt und ausgibt, wenn das aktuelle Hoch niedriger oder gleich zum vorherigen ist und zur gleichen Zeit die aktuelle Tief höher ist, als die vorherige, wird dies ein Signal einer potenziellen Doppelspitze. Wenn das aktuelle Hoch niedriger oder gleich dem vorherigen ist und gleichzeitig das aktuelle Tief niedriger ist als das vorherige, ist dies ein Signal für eine Doppelspitze.
Nachfolgend finden Sie den vollständigen Code für diese Funktionsweise:
//+------------------------------------------------------------------+ //| DT patternFinder.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { int checkBars= 5; int high1, high2, low1, low2; double highVal1, highVal2, lowVal1, lowVal2; high1=getmove(MODE_HIGH,checkBars,0); high2=getmove(MODE_HIGH,checkBars,high1+1); highVal1=NormalizeDouble(iHigh(_Symbol,_Period,high1),5); highVal2=NormalizeDouble(iHigh(_Symbol,_Period,high2),5); ObjectDelete(0,"topLine"); ObjectCreate(0,"topLine",OBJ_TREND,0,iTime(Symbol(),Period(),high2),iHigh(Symbol(),Period(),high2),iTime(Symbol(),Period(),high1),iHigh(Symbol(),Period(),high1)); ObjectSetInteger(0,"topLine",OBJPROP_COLOR,clrRed); ObjectSetInteger(0,"topLine",OBJPROP_WIDTH,3); ObjectSetInteger(0,"topLine",OBJPROP_RAY_RIGHT,true); low1=getmove(MODE_LOW,checkBars,0); low2=getmove(MODE_LOW,checkBars,low1+1); lowVal1=NormalizeDouble(iLow(_Symbol,_Period,low1),5); lowVal2=NormalizeDouble(iLow(_Symbol,_Period,low2),5); ObjectDelete(0,"bottomLine"); ObjectCreate(0,"bottomLine",OBJ_TREND,0,iTime(Symbol(),Period(),low2),iLow(Symbol(),Period(),low2),iTime(Symbol(),Period(),low1),iLow(Symbol(),Period(),low1)); ObjectSetInteger(0,"bottomLine",OBJPROP_COLOR,clrGreen); ObjectSetInteger(0,"bottomLine",OBJPROP_WIDTH,3); ObjectSetInteger(0,"bottomLine",OBJPROP_RAY_RIGHT,true); if(highVal1<=highVal2&&lowVal1>lowVal2) { Comment("Potential Double Top", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); } else if(highVal1<=highVal2&&lowVal1<lowVal2) { Comment("Double Top", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); } else Comment(" "); } int getmove(int move, int count, int startPos) { if(move!=MODE_HIGH && move!=MODE_LOW) return (-1); int currentBar=startPos; int moveReturned=getNextMove(move,count*2+1,currentBar-count); while(moveReturned!=currentBar) { currentBar=getNextMove(move,count,currentBar+1); moveReturned=getNextMove(move,count*2+1,currentBar-count); } return(currentBar); } int getNextMove(int move, int count, int startPos) { if(startPos<0) { count +=startPos; startPos =0; } return((move==MODE_HIGH)? iHighest(Symbol(),Period(),(ENUM_SERIESMODE)move,count,startPos): iLowest(Symbol(),Period(),(ENUM_SERIESMODE)move,count,startPos)); }
Die Unterschiede in diesem Code sind die Bedingungen des Musters.
Im Falle einer potenziellen Doppelspitze, wenn also highVal1 kleiner oder gleich highVal2 und lowVal1 größer als lowVal2 ist, sollte ein Signal als Kommentar auf dem Chart mit den folgenden Werten ausgegeben werden:
- Potential Double Top
- Current High
- Previous High
- Current Low
- Previous Low
if(highVal1<=highVal2&&lowVal1>lowVal2) { Comment("Potential Double Top", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); }
Im Falle einer Doppelspitze, wenn highVal1 kleiner oder gleich highVal2 und lowVal1 kleiner als lowVal2 ist, soll ein Signal als Kommentar auf dem Chart mit den folgenden Werten ausgegeben werden:
- Double Top
- Current High
- Previous High
- Current Low
- Previous Low
else if(highVal1<=highVal2&&lowVal1<lowVal2) { Comment("Double Top", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); }
Falls kein Muster einer potenziellen oder tatsächlichen Doppelspitze vorliegt, wird nichts als Kommentar ausgegeben.
else Comment(" ");
Nach dem fehlerfreien Kompilieren dieses Codes und dem Ausführen seines EA finden wir das folgende Beispiel aus dem Test als Signale.
Im Fall von Potentiellen Doppelspitze:
Wie wir im vorherigen Chart sehen können, haben wir das Signal einer potenziellen Doppelspitze, da es mit den vorgegebenen Bedingungen übereinstimmt, die ein höheres Tief und ein gleich hohes Hoch sind.
Im Fall einer Doppelspitze:
Wie wir in der vorherigen Grafik sehen können, haben wir das Signal einer Doppelspitze, da es mit den vorgegebenen Bedingungen übereinstimmt, d.h. ein niedrigeres oder gleich hohes Hoch und ein niedrigeres Tief.
Erkennen von Doppelböden
In diesem Teil werden wir lernen, wie man das entgegengesetzte Muster der Doppelspitzen erkennt, nämlich Doppelböden (eng.double bottom). Doppelböden sind ein Chart-Muster, das wir auf dem Chart sehen können und bestehen aus zwei ähnlich gleichen Tiefs, die anzeigen, dass es eine Schwäche in der Verkaufskraft und es gibt ein Potenzial, dass die Preise sich wieder nach oben bewegen werden. Es gibt viele Details, die auch von Bedeutung sein können, aber wenn wir nur seine Form berücksichtigen, werden wir feststellen, dass gleiche dem ist, was wir bereits besprochen haben. Die folgende Grafik ist ein visuelles Beispiel für einen potenziellen Doppelboden:
Wir müssen einen weiteren MQL5 EA erstellen, der verwendet werden kann, um die beiden vorherigen Muster im MetaTrader 5 zu erkennen. Wir brauchen den EA, um die beiden Tiefs und die beiden Hochs kontinuierlich zu überprüfen und ihre Positionen in Bezug zueinander zu bestimmen und dann ein bestimmtes Ergebnis auf der Grundlage der Bedingung des Musters eines Doppelbodens zu liefern. Die gleiche einfache Entwicklung im Code wird im umgekehrten Fall angewandt, um ein praktisches Muster mit einem etwas höheren oder niedrigeren Tief nicht nur das gleiche Hoch zu erreichen, also wenn das aktuelle Tief höher oder gleich dem vorherigen ist und gleichzeitig das aktuelle Hoch niedriger als das vorherige ist, aber dies wird ein Signal für einen potenziellen Doppelboden sein. Wenn das aktuelle Tief größer oder gleich dem vorherigen ist und gleichzeitig das aktuelle Hoch höher ist als das vorherige, ist dies ein Signal für einen Doppelboden.
Nachfolgend finden Sie den vollständigen Code für diese Funktionsweise:
//+------------------------------------------------------------------+ //| DB patternFinder.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { int checkBars= 5; int high1, high2, low1, low2; double highVal1, highVal2, lowVal1, lowVal2; high1=getmove(MODE_HIGH,checkBars,0); high2=getmove(MODE_HIGH,checkBars,high1+1); highVal1=NormalizeDouble(iHigh(_Symbol,_Period,high1),5); highVal2=NormalizeDouble(iHigh(_Symbol,_Period,high2),5); ObjectDelete(0,"topLine"); ObjectCreate(0,"topLine",OBJ_TREND,0,iTime(Symbol(),Period(),high2),iHigh(Symbol(),Period(),high2),iTime(Symbol(),Period(),high1),iHigh(Symbol(),Period(),high1)); ObjectSetInteger(0,"topLine",OBJPROP_COLOR,clrRed); ObjectSetInteger(0,"topLine",OBJPROP_WIDTH,3); ObjectSetInteger(0,"topLine",OBJPROP_RAY_RIGHT,true); low1=getmove(MODE_LOW,checkBars,0); low2=getmove(MODE_LOW,checkBars,low1+1); lowVal1=NormalizeDouble(iLow(_Symbol,_Period,low1),5); lowVal2=NormalizeDouble(iLow(_Symbol,_Period,low2),5); ObjectDelete(0,"bottomLine"); ObjectCreate(0,"bottomLine",OBJ_TREND,0,iTime(Symbol(),Period(),low2),iLow(Symbol(),Period(),low2),iTime(Symbol(),Period(),low1),iLow(Symbol(),Period(),low1)); ObjectSetInteger(0,"bottomLine",OBJPROP_COLOR,clrGreen); ObjectSetInteger(0,"bottomLine",OBJPROP_WIDTH,3); ObjectSetInteger(0,"bottomLine",OBJPROP_RAY_RIGHT,true); if(lowVal1>=lowVal2&&highVal1<highVal2) { Comment("Potential Double Bottom", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); } else if(lowVal1>=lowVal2&&highVal1>highVal2) { Comment("Double Bottom", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); } else Comment(" "); } int getmove(int move, int count, int startPos) { if(move!=MODE_HIGH && move!=MODE_LOW) return (-1); int currentBar=startPos; int moveReturned=getNextMove(move,count*2+1,currentBar-count); while(moveReturned!=currentBar) { currentBar=getNextMove(move,count,currentBar+1); moveReturned=getNextMove(move,count*2+1,currentBar-count); } return(currentBar); } int getNextMove(int move, int count, int startPos) { if(startPos<0) { count +=startPos; startPos =0; } return((move==MODE_HIGH)? iHighest(Symbol(),Period(),(ENUM_SERIESMODE)move,count,startPos): iLowest(Symbol(),Period(),(ENUM_SERIESMODE)move,count,startPos)); }
Die Unterschiede in diesem Code sind die Bedingungen des Musters.
Im Falle des potenziellen Doppelbodens, wenn der lowVal1 größer oder gleich dem lowVal2 ist und der highVal1 niedriger als der highVal2 ist, müssen wir ein Signal als Kommentar auf dem Chart mit den folgenden Werten erhalten:
- Potential Double Bottom
- Current High
- Previous High
- Current Low
- Previous Low
if(lowVal1>=lowVal2&&highVal1<highVal2) { Comment("Potential Double Bottom", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); }
Im Falle einer Doppelboden, wenn lowVal1 größer oder gleich lowVal2 und highVal1 größer als highVal2 ist, sollte ein Signal als Kommentar auf dem Chart mit den folgenden Werten erscheinen:
- Double Bottom
- Current High
- Previous High
- Current Low
- Previous Low
else if(lowVal1>=lowVal2&&highVal1>highVal2) { Comment("Double Bottom", "\nCurrent High ",highVal1,"\nPrevious High ",highVal2, "\nCurrent Low ",lowVal1,"\nPrevious Low ",lowVal2); }
Nach dem fehlerfreien Kompilieren dieses Codes und dem Ausführen seines EAs erhalten wir die folgenden Signale als Beispiele aus dem Test.
Im Falle des potenziellen Doppelbodens:
Wie wir in der vorherigen Grafik sehen können, haben wir das Signal eines potentielles Doppelbodens, da es eine Übereinstimmung mit den vorgegebenen Bedingungen gibt, dass es ein niedrigeres Hoch und ein gleichwertiges oder höheres Tief gibt.
Im Falle des Doppelbodens:
Wie wir im vorherigen Chart sehen können, haben wir das Signal eines Doppelbodens, da es mit den vorgegebenen Bedingungen übereinstimmt, dass es ein höheres Hoch und ein gleichwertiges oder höheres Tief gibt.
Schlussfolgerung
Die Preisaktion ist das Wichtigste für Händler, da sie auf der Grundlage des Verständnisses dieser Preisaktion handeln, und wenn sie diese sehr gut verstehen, können sie bessere Investitions- oder Handelsentscheidungen treffen. Die Preisbewegung bildet eine Menge Muster, die wir ebenfalls lesen und verstehen müssen. Wir haben versucht, in diesem Artikel zu bieten, was kann diese Aufgabe durch die Schaffung von Systemen von MQL5, um in der MetaTrader 5 Trading-Terminal verwendet werden, zu erleichtern.
Wir haben gelernt, wie man Trends (Aufwärts-, Abwärts- und Seitwärtstrend) und eines der beliebtesten Chartmuster, nämlich Doppelspitzen und deren Gegenteil den Doppelböden, erkennt, nachdem wir gelernt haben, wie man Hochs und Tiefs erkennt. Wir haben auch eine gute Basis für jedes Konzept von Trends und diesen Chart-Typ zur Verfügung gestellt, um diese erwähnten Programme oder Systeme basierend auf Ihren geeigneten Bedingungen entwickeln zu können. Nachdem Sie das Hauptkonzept zur Erstellung eines Systems zum Erkennen von Hochs und Tiefs gelernt haben, können Sie dieses System immer weiter ausbauen, um weitere Chartmuster wie Kopf und Schultern, Dreiecke, Rechtecke usw. erkennen zu können. Ich hoffe, dass Sie diesen Artikel nützlich finden, um Ihr Handels- und Handelssystem entsprechend zu entwickeln und bessere Ergebnisse aus Ihrem Handelsgeschäft zu erzielen.
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/12479
Implementierung eines ARIMA-Trainingsalgorithmus in MQL5
Wie man einen nutzerdefinierten Indikator (Heiken Ashi) mit MQL5 erstellt
Rebuy-Algorithmus: Mathematisches Modell zur Effizienzsteigerung
Einige Lektionen der Prop-Firmen (Teil 1) — Eine Einführung
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.