Lernen Sie, wie man ein Handelssystem mit dem Alligator entwickelt

Einführung

Hier ist ein neuer Artikel aus unserer Serie darüber, wie man ein Handelssystem auf der Grundlage der beliebtesten technischen Indikatoren entwickelt. In diesem Artikel werden wir den Alligator-Indikator im Detail kennenlernen, indem wir erfahren, was er ist, was er misst, wie wir ihn berechnen können und wie wir ihn lesen und verwenden können. Dann werden wir ein Handelssystem erstellen, das auf einigen einfachen Strategien basiert, die auf dem Hauptziel dieses Indikators beruhen. Wir werden diesen Indikator folgende Themen behandeln:

1. Alligator - Definition
2. Alligator - Strategie
3. Alligator - Blaupause der Strategie
4. Alligator - Handelssystem
5. Schlussfolgerung

Ich rate Ihnen, zu versuchen, das Gelernte selbst anzuwenden, insbesondere die Codes in diesem Artikel, um Ihre Programmierfähigkeiten zu entwickeln, da dies ein wichtiger Schritt ist, um dieses Ziel der Entwicklung zu erreichen. Wir werden in diesem Artikel MQL5 (MetaQuotes Language 5) IDE, die in der MetaTrader 5 Handels-Terminal eingebaut ist, wenn Sie nicht wissen, wie man den MetaTrader 5 herunterladen und wie man MQL5 können Sie das Thema der Writing MQL5 Code in MetaEditor lesen, um mehr darüber zu erfahren.

Haftungsausschluss: Alle Informationen werden in der vorliegenden Form nur zu Informationszwecken bereitgestellt und sind nicht für Handelszwecke oder als Ratschläge gedacht. Die Informationen garantieren keinen Erfolg. Wenn Sie sich dafür entscheiden, diese Materialien auf einem Ihrer Handelskonten zu verwenden, tun Sie dies auf eigenes Risiko und Sie sind allein verantwortlich.

Alligator - Definition

Der technische Indikator Alligator ist ein Trendfolgeindikator, der von Bill Williams entwickelt wurde. Er basiert darauf, dass der Trend eines Finanzmarktinstruments nur für 15% bis 30% der Zeit existiert, während er in 70% bis 85% der zeit schwankt oder sich seitwärts bewegt. Wir haben also manchmal einen Trend, entweder einen Auf- oder einen Abwärtstrend, aber die meiste Zeit haben wir Schwankungen innerhalb von Kursspannen. Wenn Sie mehr über Trends, ihre Arten und wie wir sie erkennen können, erfahren möchten, können Sie das Thema der Trenddefinition in meinem vorherigen Artikel lesen, der in diesem Zusammenhang nützlich sein wird. Er verwendet einige der Fibonacci-Zahlen in der Berechnung in gleicher Weise, wie wir sehen werden, wie es drei geglättete gleitende Durchschnitte mit einer Reihe der Zahlen fünf, acht, dreizehn Periodenlängen verwendet. Wie bereits erwähnt, besteht der Alligator-Indikator aus drei geglätteten gleitenden Durchschnitten, die sich wie folgt darstellen:

• Die Alligator Jaw (Kiefer).
• Die Alligator Teeth (Zähne).
• Die Alligator Lips (Lippen).

Wir können diesen Indikator anhand der folgenden Schritte manuell berechnen:

Die Alligator Jaw= SMMA (Medianpreis, 13, 8)

Die Alligator Teeth = SMA (Medianpreis, 8, 5)

The Alligator Lips = SMMA (Medianpreis, 5, 3)

Medianpreis = (Hoch + Tief)/2

Wobei:

SMMA - geglätteter gleitender Durchschnitt;

Medianpreis = der Medianpreis der Daten

Hoch = der Höchstpreis

Niedrig = der Tiefstpreis

Nach den vorangegangenen Schritten erhalten wir den Alligator-Indikator, den wir jedoch nicht manuell berechnen müssen, da er als integrierter Indikator im MetaTrader 5-Terminal vorhanden ist und wir ihn nur aus den verfügbaren technischen Indikatoren auswählen müssen, wie im Folgenden beschrieben:

Beim Öffnen des MetaTrader 5 Terminals klicken wir auf Einfügen --> Indikatoren --> Bill Williams --> Alligator.

Danach werden wir die Parameter wie folgt finden:

1- Einstellen des Zeitraums des Alligators Kiefers (Jaw).

2- Einstellen der horizontalen Verschiebung des Alligators Kiefers (Jaw).

3- Einstellen des Zeitraums des Alligators Zähne (Teeth).

4- Einstellen der horizontalen Verschiebung des Alligators Zähne (Teeth).

5- Einstellen des Zeitraums des Alligators Lippen (Lips).

6- Einstellen der horizontalen Verschiebung des Alligators Lippen (Lips).

7- Einstellen der Glättungsmethode.

8- Einstellen des verwendeten Preistyp.

Über das folgende Fenster können wir den Stil des Indikators bestimmen:

1- Einstellen der Farbe der Linie des Kiefers (Jaws).

2- Einstellen des Typs der Linie des Kiefers (Jaws).

3- Einstellen der Dicke der Linie des Kiefers (Jaws).

4- Einstellen der Farbe der Linie der Zähne (Teeth).

5- Einstellen des Typs der Linie der Zähne (Teeth).

6- Einstellen der Dicke der Linie der Zähne (Teeth).

7- Einstellen der Farbe der Linie der Lippen (Lips).

8- Einstellen des Typs der Linie der Lippen (Lips).

9- Einstellen der Dicke der Linie der Lippen (Lips).

Nachdem Sie alle Parameter festgelegt und auf „OK“ gedrückt haben, können Sie feststellen, dass der Indikator wie folgt auf dem Chart läuft:

Wie wir im vorherigen Chart sehen können, haben wir den Indikator in das Chart eingefügt und wir haben drei Linien:

1- Alligator Lips.

2- Alligator Teeth.

3- Alligator Jaws.

Wir können den Indikator einfach ablesen, indem wir die Position dieser Linien auf den Kursen beobachten. Wenn der Kurs über den Lippen, den Zähnen und dann den Kiefern liegt, können wir sagen, dass der Trend nach oben geht. Wenn der Preis unter den Lippen, Zähnen und Kiefer liegt, kann man sagen, dass der Trend nach unten geht. Wenn sich der Kurs durch die drei Linien bewegt, können wir sagen, dass wir eine Seitwärtsbewegung haben.

Alligator - Strategie

Es gibt viele Möglichkeiten, den Alligator-Indikator im Handel zu verwenden, aber ich werde einfache Strategien erwähnen, die auf der Grundlage der Hauptidee dieses Themas für die Ausbildung verwendet werden können, und Sie müssen sie testen, bevor Sie sie in Ihrem realen Konto verwenden, um sicherzustellen, dass sie profitabel sein werden. Es kann sein, dass Sie feststellen, dass Sie die genannten Strategien optimieren müssen, und das ist normal, dass Sie das tun können, um die beste Formel zu erreichen, die für Ihren Handelsstil nützlich sein kann.

• Strategie eins: Alligator Trendidentifikation:

Auf der Grundlage dieser Strategie müssen wir Signale für steigende und fallende Kurse erhalten, die auf bestimmten Bedingungen basieren. Wenn der Wert der Lippen größer ist als die beiden zwei Werte von Zähne und Kiefer, und gleichzeitig der Wert der Zähne größer als der Wert des Kiefers, dann ist das ein bullisches Signal. Wenn der Wert der Lippen kleiner ist als die beiden zwei Werte von Zähne und Kiefer, und gleichzeitig der Wert der Zähne kleiner als der Wert des Kiefers, dann ist das ein bärisches Signal.

lips > teeth, lips > jaws, und teeth > jaws --> bullish (aufwärts)

lips < teeth, lips < jaws, und teeth < jaws --> bärisch (abwärts)

• Strategie zwei: Alligator Signal-System:

Auf der Grundlage dieser Strategie müssen wir Kauf- und Verkaufssignale erhalten, die von der Überkreuzung der Lippen-, Zahn- und Kieferlinien abhängen. Wenn der Wert der Lippen größer ist als der Wert der Zähne und des Kiefers, ist dies ein Kaufsignal. Im anderen Fall, wenn der Wert der Lippen niedriger ist als der Wert der Zähne und des Kiefers, ist dies ein Verkaufssignal.

lips > teeth, lips > jaws --> buy (kaufen)

lips < teeth, lips < jaws --> sell (verkaufen)

• Strategie drei: Alligator Erweiterung des Signals-Systems:

Auf der Grundlage dieser Strategie müssen wir Kauf- und Verkaufssignale erhalten, die auf dem Kreuzen der Linien von Lippen, Zähnen und Kiefer basieren und danach auf dem Kreuzen von Schlusskurs und Zähnen. Wenn die Linie der Lippen unter den Zähne und dem Kiefer liegt, und der Schlusskurs größer ist als der Wert der Zähne, dann es ist ein Kaufsignal. Im anderen Fall, wenn die Linie der Lippen über den Zähne und dem Kiefer liegt, und der Schlusskurs kleiner ist als der Wert der Zähne, dann es ist ein Verkaufssignal.

lips < teeth, lips < jaws und closing price > teeth --> buy (kaufen)

lips > teeth, lips > jaws und closing price < teeth --> sell (verkaufen)

Alligator - Blaupause der Strategie

Jetzt müssen wir ein Handelssystem erstellen, das auf den im vorigen Thema erwähnten Strategien basiert, und um das zu tun, werden wir einen Schritt-für-Schritt-Plan entwerfen, der uns bei der Erstellung dieses Handelssystems hilft.

• Strategie eins: Alligator Trendidentifikation:

Nach dieser Strategie müssen wir ein Handelssystem entwickeln, das Signale für steigende oder fallende Divergenzen generieren kann, indem wir vier Werte kontinuierlich überprüfen.

• Wert der Lippen
• Wert der Zähne
• Wert des Kiefers

Wir brauchen das Handelssystem, um die Positionen dieser Werte zu bestimmen und auf dieser Grundlage geeignete Signale zu erzeugen. Wenn die Lippenlinie über der der Zähne liegt und über der des Kiefers und die Linie der Zähne über der des Kiefers, soll das Handelssystem in diesem Fall das Folgende als Kommentar auf dem Chart anzeigen:

• Bullish
• Jaws value = n
• teeth value = n
• lips value = n

Im anderen Fall, wenn die Lippenlinie unter der der Zähne liegt und unter der des Kiefers und die Linie der Zähne unter der des Kiefers, soll das Handelssystem in diesem Fall das Folgende als Kommentar auf dem Chart anzeigen:

• Bearish
• Jaws value = n
• teeth value = n
• lips value = n

Nachfolgend finden Sie eine schrittweise Blaupause für dieses Handelssystem:

• Strategie zwei: Alligator Signal-System:

Gemäß dieser Strategie müssen wir ein Handelssystem entwickeln, das Kauf- oder Verkaufssignale generiert, indem es kontinuierlich die folgenden Werte überprüft, um die Positionen jedes einzelnen von ihnen zu bestimmen:

• Wert der Lippen
• Wert der Zähne
• Wert des Kiefers

Wenn die Lippenlinie über der der Zähne und gleichzeitig über der des Kiefers, soll das Handelssystem in diesem Fall einen Kommentar auf dem Chart anzeigen:

• Buy
• Jaws value = n
• teeth value = n
• lips value = n

Im anderen Fall, wenn die Lippenlinie unter der der Zähne und gleichzeitig unter der des Kiefers, soll das Handelssystem in diesem Fall einen Kommentar auf dem Chart anzeigen:

• Sell
• Jaws value = n
• teeth value = n
• lips value = n

Nachfolgend finden Sie eine schrittweise Blaupause für dieses Handelssystem:

• Strategie drei: Alligator Erweiterung des Signals-Systems:

Gemäß dieser Strategie müssen wir ein Handelssystem erstellen, das Kauf- und Verkaufssignale generiert, die auf der Überprüfung der folgenden Werte basieren, um die Position eines jeden von ihnen zu bestimmen:

• Wert der Lippen
• Wert der Zähne
• Wert des Kiefers
• Schlusskurs

Wenn der Lippenwert niedriger ist als der Wert der Zähne, die Lippenlinie unter der des Kiefers und der Schlusskurs über dem Wert der Zähne liegt, soll das Handelssystem einen Kommentar als Signal mit dem Folgenden auf dem Chart anzeigen:

• Buy
• Lips value = n
• Teeth value = n
• Closing price = n
• Jaws value = n

Wenn der Lippenwert größer ist als der Wert der Zähne, die Lippenlinie über der des Kiefers und der Schlusskurs unter dem Wert der Zähne liegt, soll das Handelssystem einen Kommentar als Signal mit dem Folgenden auf dem Chart anzeigen:

• Sell
• Lips value = n
• Teeth value = n
• Closing price = n
• Jaws value = n

Nachfolgend finden Sie eine schrittweise Blaupause für dieses Handelssystem:

Alligator - Handelssystem

Nun werden wir für jede der genannten Strategien ein Handelssystem erstellen, das im MetaTrader 5 Terminal ausgeführt wird, um die gewünschten Signale automatisch zu generieren. Zunächst werden wir ein Basis-Handelssystem erstellen, um ein Signal der Alligator-Komponentenwerte zu erzeugen, das wir in unserem Handelssystem verwenden können. Im Folgenden werden die Schritte zur Erstellung eines solchen Systems beschrieben:

Erstellen wir die Arrays für jede der Alligator-Komponenten (Lippen, Zähne, Kiefer bzw. Lips, Teeth, Jaws).

   double jawsArray[];
   double teethArray[];
   double lipsArray[]; 

Wir legen die Reihung der Daten in diesen Arrays mit Hilfe der Funktion „ArraySetAsSeries“ fest. Ihre Parameter:

• array[]
• flag

   ArraySetAsSeries(jawsArray,true);
   ArraySetAsSeries(teethArray,true);
   ArraySetAsSeries(lipsArray,true);

Definition des Alligators mit Hilfe der Funktion „iAlligator“. Ihre Parameter:

• symbol: Wir verwenden _Symbol für das aktuelle Symbol.
• period: Wir verwenden (_Period) für den aktuellen Zeitrahmen.
• jaw_period: Die Periodenlänge für die Berechnung des Kiefer, wir verwenden 13.
• ma_shift: Die horizontale Verschiebung, wir verwenden 8.
• teeth_period: Die Periodenlänge für die Berechnung der Zähne, wir verwenden 8.
• teeth_shift: Die horizontale Verschiebung der Zähne, wir verwenden 5.
• lips_period: Die Periodenlänge für die Berechnung der Lippen, wir verwenden 5.
• lips_shift: Die horizontale Verschiebung der Lippen, wir verwenden 3.
• ma_method: Der Typ des gleitenden Durchschnitts, wir verwenden MODE_SMA.
• applied_price: Der Preistyp, wir verwenden den Medianpreis (PRICE_MEDIAN).

int alligatorDef=iAlligator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);

Abrufen von Daten und Speichern von Ergebnissen mit Hilfe der Funktion „CopyBuffer“. Ihre Parameter:

• indicator_handle: Die Variable des Indikator-Handles (alligatorDef).
• buffer_num: Die Nummer des Indikatorpuffers, wir verwenden 0 für den Kiefer, 1 für Zähne und 2 für die Lippen.
• start_pos: Als Startposition verwenden wir 0.
• count: Die zu kopierenden Anzahl von Werten, wir benötigen 3.
• buffer[]: Das Zielarray der abgerufenen Werte, wir verwenden jawsArray, teethArray und lipsArray.

   CopyBuffer(alligatorDef,0,0,3,jawsArray);
   CopyBuffer(alligatorDef,1,0,3,teethArray);
   CopyBuffer(alligatorDef,2,0,3,lipsArray);

Ermitten der Werte der drei Komponenten.

   double jawsValue=NormalizeDouble(jawsArray[0],5);
   double teethValue=NormalizeDouble(teethArray[0],5);
   double lipsValue=NormalizeDouble(lipsArray[0],5);

Kommentare der drei Komponenten des Indikators.

   Comment("jawsValue = ",jawsValue,"\n",
   "teethValue = ",teethValue,"\n",
   "lipsValue = ",lipsValue);

Nachfolgend der vollständige Code zur Erstellung dieses einfachen Handelssystems.

//+------------------------------------------------------------------+
//|                                      Simple Alligator System.mq5 |
//|                                  Copyright 2022, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
//--------------------------------------------------------------------
void OnTick()
  {
   //creating price array
   double jawsArray[];
   double teethArray[];
   double lipsArray[];   
   //Sorting data
   ArraySetAsSeries(jawsArray,true);
   ArraySetAsSeries(teethArray,true);
   ArraySetAsSeries(lipsArray,true);
   //define Alligator
   int alligatorDef=iAlligator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);      
   //define data and store result
   CopyBuffer(alligatorDef,0,0,3,jawsArray);
   CopyBuffer(alligatorDef,1,0,3,teethArray);
   CopyBuffer(alligatorDef,2,0,3,lipsArray);
   //get value of current data
   double jawsValue=NormalizeDouble(jawsArray[0],5);
   double teethValue=NormalizeDouble(teethArray[0],5);
   double lipsValue=NormalizeDouble(lipsArray[0],5);
   //comment on the chart
   Comment("jawsValue = ",jawsValue,"\n",
   "teethValue = ",teethValue,"\n",
   "lipsValue = ",lipsValue);
  }
//+------------------------------------------------------------------+

Nach dem Kompilieren dieses Codes finden wir ihn im Navigator unter dem Ordner Expert Advisors wie folgt:

Durch Ziehen und Ablegen auf dem gewünschten Chart erscheint das nachstehende Fenster.

Wenn Sie auf „OK“ klicken, nachdem Sie das Häkchen neben „Algo Trading zulassen“ gesetzt haben, wird der Experte wie folgt an den Chart gestartet:

Wie wir auf dem Chart in der oberen rechten Ecke sehen können, läuft der Experte. Jetzt sind wir bereit, Signale zu empfangen. Das Folgende ist ein Beispiel für das Testen von generierten Signalen:

Wie in der vorangegangenen Tabelle zu sehen ist, gibt es in der linken oberen Ecke einen Kommentar mit den folgenden Werten:

Jaws value = n

teeth value = n

lips value = n

• Strategie eins: Alligator Trendidentifikation:

Wir können ein Handelssystem erstellen, das auf dieser Strategie basiert, wie der folgende vollständige Code:

//+------------------------------------------------------------------+
//|                                   Alligator Trend Identifier.mq5 |
//|                                  Copyright 2022, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
void OnTick()
  {
//creating three arrays of Alligator components
   double jawsArray[];
   double teethArray[];
   double lipsArray[];
//Sorting data
   ArraySetAsSeries(jawsArray,true);
   ArraySetAsSeries(teethArray,true);
   ArraySetAsSeries(lipsArray,true);
//define Alligator
   int alligatorDef=iAlligator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);
//define data and store result
   CopyBuffer(alligatorDef,0,0,13,jawsArray);
   CopyBuffer(alligatorDef,1,0,13,teethArray);
   CopyBuffer(alligatorDef,2,0,13,lipsArray);
//get value of current data
   double jawsValue=NormalizeDouble(jawsArray[0],5);
   double teethValue=NormalizeDouble(teethArray[0],5);
   double lipsValue=NormalizeDouble(lipsArray[0],5);
//conditions of strategy
   if(lipsValue>teethValue && lipsValue>jawsValue && teethValue>jawsValue)
     {
      Comment("Bullish","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue);
     }
   if(lipsValue<teethValue && lipsValue<jawsValue && teethValue<jawsValue)
     {
      Comment("Bearish","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue);
     }
  }
//+------------------------------------------------------------------+

Unterschiede in diesem Code:

Bedingungen der Strategie, im Falle eines Aufwärtstrends:

   if(lipsValue>teethValue && lipsValue>jawsValue && teethValue>jawsValue)
     {
      Comment("Bullish","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue);
     }

Im Falle eines Abwärtstrends:

   if(lipsValue<teethValue && lipsValue<jawsValue && teethValue<jawsValue)
     {
      Comment("Bearish","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue);
     }

Nach dem Kompilieren dieses Codes und dem Ausführen des erstellten Experten, so wie wir es gelernt haben, werden wir feststellen, dass dieser EA auf dem Chart wie folgt läuft ist:

Wie wir im vorherigen Chart an der Ecke rechts oben sehen können, läuft und wir sind bereit, unsere Auf- und Abwärts-Signale auf der Grundlage dieser Strategie zu erhalten. Im Folgenden finden Sie Beispiele für diese Signale:

Im Falle eines Aufwärtstrends:

Wie in der vorangegangenen Grafik zu sehen ist, haben wir einen Kommentar als Signal in der oberen linken Ecke wie folgt:

• Bullish
• Jaws value = n
• teeth value = n
• lips value = n 

Wir sehen drei Linien, die sich unter den Preisen bewegen, also haben wir ein Aufwärtssignal.

Im Falle eines Abwärtstrends:

Wie wir im obigen Chart sehen können, erscheint der Kommentar des Abwärtssignals in der oberen linken Ecke wie folgt:

• Bearish
• Jaws value = n
• teeth value = n
• lips value = n

Wir haben drei Linien, die sich über den Preisen bewegen, also haben wir ein Abwärtssignal.

• Strategie zwei: Alligator Signal-System:

Der folgende Code dient der Erstellung eines Handelssystems auf der Grundlage dieser Strategie:

//+------------------------------------------------------------------+
//|                                    Alligator Signals System .mq5 |
//|                                  Copyright 2022, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
void OnTick()
  {
//creating three arrays of Alligator components
   double jawsArray[];
   double teethArray[];
   double lipsArray[];
//Sorting data
   ArraySetAsSeries(jawsArray,true);
   ArraySetAsSeries(teethArray,true);
   ArraySetAsSeries(lipsArray,true);
//define Alligator
   int alligatorDef=iAlligator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);
//define data and store result
   CopyBuffer(alligatorDef,0,0,13,jawsArray);
   CopyBuffer(alligatorDef,1,0,13,teethArray);
   CopyBuffer(alligatorDef,2,0,13,lipsArray);
//get value of current data
   double jawsValue=NormalizeDouble(jawsArray[0],5);
   double teethValue=NormalizeDouble(teethArray[0],5);
   double lipsValue=NormalizeDouble(lipsArray[0],5);
//conditions of strategy
   if(lipsValue>teethValue && lipsValue>jawsValue)
     {
      Comment("Buy","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue);
     }
   if(lipsValue<teethValue && lipsValue<jawsValue)
     {
      Comment("Sell","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue);
     }
  }
//+------------------------------------------------------------------+

Unterschiede in diesem Code:

Bedingungen für diese Strategie.

Im Falle eines Kaufsignals:

   if(lipsValue>teethValue && lipsValue>jawsValue)
     {
      Comment("Buy","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue);
     }

Im Falle eines Verkaufssignals:

   if(lipsValue<teethValue && lipsValue<jawsValue)
     {
      Comment("Sell","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue);
     }

Nach dem Kompilieren dieses Codes und dem Ausführen im Handelsterminal, können wir feststellen, dass er auf dem Chart läuft, wie man sieht:

Wir sehen in der oberen rechten Ecke des obigen Charts, dass der EA läuft und wir bereit sind, unsere Kauf- oder Verkaufssignale basierend auf dieser Strategie zu empfangen.

Im Falle eines Kaufsignals:

 

Wie wir sehen können, erscheint das gewünschte Signal wie folgt:

• Buy
• Jaws value = n
• teeth value = n
• lips value = n

Wir haben drei Linien, die sich unter den Preisen bewegen, also haben wir ein Kaufsignal.

Im Falle eines Verkaufssignals:

Wir haben unser gewünschtes Signal mit den folgenden Werten:

• Sell
• Jaws value = n
• teeth value = n
• lips value = n

Wir haben drei Linien, die sich über den Preisen bewegen, also haben wir ein Verkaufssignal.

• Strategie drei: Alligator Erweiterung des Signals-Systems:

Das Folgende ist der vollständige Code zum Erstellen eines Handelssystems für diese Strategie:

//+------------------------------------------------------------------+
//|                         Alligator Signals System Enhancement.mq5 |
//|                                  Copyright 2022, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
void OnTick()
  {
//creating three arrays of Alligator components
   double jawsArray[];
   double teethArray[];
   double lipsArray[];
   MqlRates pArray[];
//Sorting data
   ArraySetAsSeries(jawsArray,true);
   ArraySetAsSeries(teethArray,true);
   ArraySetAsSeries(lipsArray,true);
   int Data=CopyRates(_Symbol,_Period,0,1,pArray);
//define Alligator
   int alligatorDef=iAlligator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);
//define data and store result
   CopyBuffer(alligatorDef,0,0,13,jawsArray);
   CopyBuffer(alligatorDef,1,0,13,teethArray);
   CopyBuffer(alligatorDef,2,0,13,lipsArray);
//get value of current data
   double jawsValue=NormalizeDouble(jawsArray[0],5);
   double teethValue=NormalizeDouble(teethArray[0],5);
   double lipsValue=NormalizeDouble(lipsArray[0],5);
//conditions of strategy
   if(lipsValue<teethValue && lipsValue<jawsValue && pArray[0].close>teethValue)
     {
      Comment("Buy","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "closingPrice = ",pArray[0].close,"\n",
              "lipsValue = ",lipsValue);
     }
   if(lipsValue>teethValue && lipsValue>jawsValue && pArray[0].close<teethValue)
     {
      Comment("Sell","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "closingPrice = ",pArray[0].close,"\n",
              "lipsValue = ",lipsValue);
     }
  }
//+------------------------------------------------------------------+

Unterschiede in diesem Code:

Erstellen eines weiteren Arrays für Preise mit Hilfe der Funktion „MqlRates“, um Informationen über Preise, Volumen und Spread abzurufen.

MqlRates pArray[];

Abrufen der historischen Daten von MqlRates durch Verwendung von „CopyRates“. Die Parameter:

• symbol: Um den Namen des Symbols zu bestimmen, wir verwenden _Symbol.
• timeframe: Um den Zeitraum zu bestimmen, wir verwenden _period.
• start_pos: Um die Startposition zu bestimmen, wir verwenden 0.
• count: Um die zu kopierenden Anzahl zu bestimmen, wir benötigen 1.
• rates_array[]: Um das zu Zielarray zu bestimmen, wir verwenden pArray.

int Data=CopyRates(_Symbol,_Period,0,1,pArray);

Bedingungen der Strategie.

Im Falle eines Kaufsignals:

   if(lipsValue<teethValue && lipsValue<jawsValue && pArray[0].close>teethValue)
     {
      Comment("Buy","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "closingPrice = ",pArray[0].close,"\n",
              "lipsValue = ",lipsValue);
     }

Im Falle eines Verkaufssignals:

   if(lipsValue>teethValue && lipsValue>jawsValue && pArray[0].close<teethValue)
     {
      Comment("Sell","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "closingPrice = ",pArray[0].close,"\n",
              "lipsValue = ",lipsValue);
     }

Nach dem Kompilieren dieses Codes und dem Ausführen des EA sehen wir, dass er auf dem Chart läuft, wie im Folgenden dargestellt, um unsere Kauf- und Verkaufssignale anzuzeigen.

Wir sehen in der oberen rechten Ecke, der EA läuft, und wir können unsere gewünschten Signale wie im folgenden Testbeispiel erhalten.

Im Falle eines Kaufsignals:

Wir sehen den Kommentar in der oberen linken Ecke wie folgt:

• Buy
• Jaws value = n
• teeth value = n
• Closing price = n
• lips value = n 

Da sich die drei Linien über den Preisen bewegen, können wir feststellen, dass sich der Schlusskurs über den Zähnen (rot) des Alligator befindet.

Im Falle eines Verkaufssignals:

Wir haben einen Kommentar als Signal in der linken oberen Ecke:

• Sell
• Jaws value = n
• teeth value = n
• Closing price = n
• lips value = n

Da sich drei Linien über den Preisen bewegen, können wir feststellen, dass sich der Schlusskurs unter den Zähnen (rot) des Alligators befindet.

Schlussfolgerung

Wir haben uns in diesem Artikel ausführlich mit dem technischen Indikator Alligator beschäftigt, der neben der Generierung von Kauf- und Verkaufssignalen auch zur Trendbestätigung verwendet werden kann. Wir haben gelernt, wie wir sie manuell berechnen können und wie wir sie auf der Grundlage der genannten einfachen Strategien verwenden können:

• Alligator Trendidentifikation: Um Auf- und Abwärtssignale zu erzeugen, die auf der Position der drei Linien des Alligators (Lippen, Zähne und Kiefer) basieren.
• Alligator Signal-System: Zur Generierung von Kauf- oder Verkaufssignalen nach der klassischen Methode des Kreuzens von Linien, die auf dem Kreuzen der drei Linien des Indikators basiert.
• Alligator Erweiterung des Signals-Systems: Um Kauf- oder Verkaufssignale durch eine andere Methode zu generieren, um diese Signale früher auf der Grundlage der Position von drei Linien der Indikatoren und der Kreuzung zwischen dem Schlusskurs und die Zähne zu erhalten. 

Wir haben für jede der genannten Strategien einen Schritt-für-Schritt-Entwurf erstellt, der uns dabei hilft, unsere Ideen zu organisieren und ein Handelssystem reibungslos, einfach und effektiv zu erstellen. Wir haben auch ein Handelssystem für jede erwähnte Strategie erstellt, das im MetaTrader 5-Handelsterminal verwendet werden kann und automatisch Signale generiert, wie wir es entworfen und kodiert haben. Ich muss hier noch einmal bestätigen, dass Sie jede erwähnte Strategie testen müssen, bevor Sie sie auf Ihrem realen Konto verwenden, um sicherzustellen, dass sie nützlich und profitabel für Sie sind, da es nichts gibt, das für alle von uns geeignet ist, außerdem ist das Hauptziel hier, Wissen zu teilen oder der Hauptzweck dieses Artikels ist nur Bildung.

Ich hoffe, dass Sie versuchen werden, das Gelernte selbst anzuwenden. Ich habe Ihnen geraten, Ihre Programmierfähigkeiten zu verbessern und den vollen Nutzen aus der Lektüre dieses Artikels zu ziehen, und ich hoffe, dass Sie ihn für Ihren Handel nützlich fanden und nützliche Einblicke in das Thema dieses Artikels oder sogar in ein verwandtes Thema erhielten. Wenn Sie mehr ähnliche Artikel lesen möchten, können Sie meine früheren Artikel in dieser Serie lesen, wie wir die beliebtesten technischen Indikatoren wie Stochastik, RSI, Bollinger Bands, gleitende Durchschnitte, Hüllkurven, MACD, ADX, usw., und wie wir ein Handelssystem auf der Grundlage von ihnen erstellen können.