Lernen Sie, wie man ein Handelssystem mit den Fraktalen entwickelt

Einführung

Ein neuer Artikel mit einem neuen technischen Indikator in unserer Serie, in der wir lernen, wie man ein Handelssystem entwickelt, das auf einem der beliebtesten technischen Indikatoren basiert, nämlich dem Fraktal-Indikator. In den folgenden Abschnitten werden wir uns eingehend damit befassen:

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

Wir werden lernen, was er ist, was er misst und wie wir ihn manuell berechnen können, um die Grundidee dahinter zu verstehen. Wir werden lernen, wie wir ihn durch einfache Handelsstrategien, die auf dem Grundkonzept des Indikators basieren, zu unseren Gunsten einsetzen können. Danach werden wir auf der Grundlage dieser Strategien ein Handelssystem erstellen, das im MetaTrader 5-Handelsterminal verwendet werden kann, um automatische Signale zu erzeugen.

Wir werden die MQL5 (MetaQuotes Language 5) verwenden, die in die IDE des MetaTrader 5-Terminals integriert ist, um unsere Codes zu schreiben. Wenn Sie nicht wissen, wie man den MetaTrader 5 und MQL5 herunterlädt und verwendet, können Sie den Artikel MQL5-Code im MetaEditor schreiben lesen, um mehr darüber zu erfahren. Übrigens rate ich Ihnen, das Gelernte selbst anzuwenden, wenn Sie Ihre Programmierkenntnisse verbessern wollen.

Sie müssen jede vorgestellte Strategie testen, bevor Sie sie in Ihrem realen Konto anwenden, denn das Hauptziel dieses Artikels ist Ausbildung. Außerdem gibt es nichts, was für jeden geeignet ist. Sie müssen also sicherstellen, dass dies für Ihren Handel zweckmäßig ist.

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.

Fraktale - Definition

Der Indikator der Fraktale, eng. Fractals, wurde von Bill Williams entwickelt. Er wurde entwickelt, um zu versuchen, die potenziellen Bewegungen des Preisgeschehens zu antizipieren, indem er Auf- oder Abwärtssignalen gibt. Das Aufwärtssignal deutet auf eine mögliche Aufwärtsbewegung hin, während das Abwärtssignal auf eine mögliche Abwärtsbewegung hindeutet. Man kann auch sagen, dass dieser Indikator versucht, Hochs und Tiefs auf dem Chart zu antizipieren. Wir können diese Signale erkennen, indem wir die generierten Pfeile auf dem Chart unter und über den Preisen betrachten.

Er bildet zwei verschiedene Pfeile, den nach oben gerichteten Fraktalpfeil und den nach unten gerichteten Fraktalpfeil. Wenn Sie nach der Berechnungsmethode für diese beiden zu bildenden Pfeile fragen, lautet die Antwort auf diese Frage wie folgt:

Der Fraktal-Indikator benötigt ein bestimmtes Muster der Kursbewegung, das sich auf dem Chart in beide Richtungen - nach oben oder nach unten - ausbildet.

Für die aufwärts gerichteten Fraktale auf der Preisaktion benötigen wir Folgendes:

• Mindestens fünf aufeinanderfolgende Kerzen oder Balken.
• Das höchstes Hoch liegt auf der mittleren Kerze (3. Kerze).
• Niedrigere Hochs befinden sich auf beiden Seiten dieses Hochs.
• Nachdem die fünfte Kerze mit den gleichen vorherigen Bedingungen schließt, wird der Aufwärtspfeil des Fraktals oberhalb der Kerze (3. Kerze) gebildet.

Für die abwärts gerichteten Fraktale auf der Preisaktion benötigen wir Folgendes:

• Mindestens fünf aufeinanderfolgende Kerzen oder Balken.
• Das tiefste Tief liegt auf der mittleren Kerze (3. Kerze).
• Höhere Tiefs befinden sich auf beiden Seiten dieses Tiefs.
• Nachdem die fünfte Kerze mit den vorherigen Bedingungen schließt, wird der Abwärtspfeil des Fraktals unterhalb der Kerze (3. Kerze) gezeichnet.

Glücklicherweise müssen wir diese vorherigen Schritte nicht durchführen, um den Fractals-Indikator auf unserem Chart zu zeichnen, da er im MetaTrader 5 bereits für uns bereitsteht. Wir können dies tun, indem wir das MetaTrader 5-Terminal öffnen und drücken,

Einfügen --> Indikatoren --> Bill Williams --> Fractals

Nachdem Sie Fraktale ausgewählt haben, finden Sie das folgende Fenster mit den Parametern des Indikators:

1- Bestimmung der Farbe der Pfeile.

2- Bestimmung der Dicke.

Nachdem Sie OK gedrückt haben, wird der Indikator wie folgt in das Chart gestartet:

Wie wir sehen können, befinden sich oberhalb und unterhalb der Kerzen Pfeile, die auf die potenzielle Bewegung der Kursbewegung hinweisen. Wir haben Abwärtspfeile unter Kerzen, die eine potenzielle Aufwärtsbewegung anzeigen, und Aufwärtspfeile über anderen Kerzen, die eine potenzielle Abwärtsbewegung anzeigen.

Fraktale - Strategie

Wir werden lernen, wie man diesen Fraktal-Indikator anhand einfacher Strategien verwendet, die auf dem Hauptkonzept dieses technischen Indikators basieren. Wir werden den Fraktal-Indikator als eigenständigen Indikator verwenden und dann lernen, wie man ihn mit anderen technischen Indikatoren kombiniert, um mehr Erkenntnisse zu gewinnen und seine Signale zu verbessern.

Strategie eins: Hohe und tiefe Fraktale

Bei dieser Strategie müssen wir Hoch- und Tiefsignale erhalten, die auf den Positionen der Höchst- und Tiefstwerte der Fraktale basieren. Wenn der Indikator den unteren Pfeil erzeugt hat, handelt es sich um ein niedriges Signal. Wenn die Fraktale den oberen Pfeil erzeugt haben, ist dies ein hohes Signal.

Einfach:

Unterer Pfeil --> Fraktal-Tief

Oberer Pfeil --> Fraktal-Hoch

Strategie zwei: Fraktale mit MA

Nach dieser Strategie müssen wir Kauf- und Verkaufssignale erhalten, die auf der Richtung der Preisaktion basieren, die auf der Position des Preises und des gleitenden Durchschnitts zusätzlich zu den generierten Signalen des Fraktalindikators beruht. Wenn der Schlusskurs über dem gleitenden Durchschnitt liegt und der Fraktal-Indikator einen unteren Pfeil erzeugt hat, handelt es sich um ein Kaufsignal. Wenn der Schlusskurs unter dem gleitenden Durchschnitt liegt und der Fraktal-Indikator den oberen Pfeil erzeugt hat, handelt es sich um ein Verkaufssignal.

Einfach:

Der Schlusskurs > MA und erzeugter unterer Pfeil --> Kaufsignal

Der Schlusskurs < MA und erzeugter höherer Pfeil --> Verkaufssignal

Strategie drei: Fraktale mit Alligator

Nach dieser Strategie müssen wir Kauf- und Verkaufssignale erhalten, die auf der Richtung der Preisaktion basieren und von der Position des Alligator-Indikators zusätzlich zu den generierten Signalen des Fraktal-Indikators abhängen. Wenn die Lippenlinie des Alligators über denen von Zähnen und Kiefer, die Zahnlinie über der des Kiefers, der Schlusskurs über der der Zähne liegt und das Signal des Fraktalindikators ein unterer Pfeil ist, handelt es sich um ein Kaufsignal. Im anderen Szenario, wenn die Lippenlinie niedriger als die von Zähne und Kiefer ist, die Zähne niedriger als der Kiefer, der Schlusskurs niedriger als die Zähne ist und das Fraktalsignal ein oberer Pfeil ist, ist dies ein Verkaufssignal.

Einfach:

Lippen > Zähne und Kiefer, Zähne > Kiefer, Schlusskurs > Zähne und das Fraktalsignal ist ein unterer Pfeil --> Kaufsignal

Lippen < Zähne und Kiefer, Zähne < Kiefer, Schlusskurs < Zähne und das Fraktalsignal ist ein oberer Pfeil --> Verkaufssignal

Fraktale - Blaupause der Strategie

Wir werden für jede der genannten Strategien eine Schritt-für-Schritt-Blaupause entwerfen, die uns dabei hilft, unser Handelssystem einfach zu erstellen, indem wir unsere Ideen ordnen.

1. Hohe und tiefe Fraktale

Auf der Grundlage dieser Strategie müssen wir ein Handelssystem erstellen, mit dem die Höchst- und Tiefstwerte des Fraktal-Indikators als Kommentar auf dem Chgart angezeigt werden können, indem der hohe FracUp-Wert und der tiefe FracDown-Wert kontinuierlich überprüft werden. Wenn fracUp größer als Null oder nicht leer ist und fracDown leer ist, muss das Handelssystem ein Signal auf dem Chart als Kommentar mit dem folgenden Wert zurückgeben:

• Fractals High around: n

Im anderen Fall, wenn fracDown größer als Null oder nicht leer und fracUp einen leeren Wert hat, muss das Handelssystem ein Signal auf dem Chart als Kommentar mit dem folgenden Wert zurückgeben:

• Fractals Low around: n

Das Folgenden ist die Blaupause dieser Strategie:

2. Fraktale mit MA

Auf der Grundlage dieser Strategie müssen wir ein Handelssystem erstellen, das Kauf- und Verkaufssignale als Kommentar auf dem Chart zurückgibt, basierend auf einer kontinuierlichen Überprüfung der folgenden Werte:

• Der Schlusskurs
• Wert des EMA (Exponentieller gleitender Durchschnitt)
• fracDown-Wert
• fracUp-Wert

Wenn der Schlusskurs größer ist als der EMA-Wert und der Wert von fracDown nicht gleich einem leeren Wert ist, muss das Handelssystem die folgenden Werte zurückgeben:

• Buy
• Current EMA
• Fractals Low value: n

Im anderen Fall, wenn der Schlusskurs unter dem EMA-Wert liegt und der FracUp-Wert nicht gleich einem leeren Wert ist, muss das Handelssystem die folgenden Werte zurückgeben:

• Sell
• Current EMA
• Fractals High value: n

Das folgende Schaubild bezieht sich auf diese Blaupause:

3. Fraktale mit Alligator

Auf der Grundlage dieser Handelsstrategie müssen wir ein System erstellen, mit dem wir Kauf- und Verkaufssignale generieren können, indem wir die Positionen kontinuierlich auf die folgenden Werte überprüfen:

• Der Wert der Lippen
• Der Wert der Zähne
• Der Wert des Kiefers
• Der Schlusskurs
• Der FracDown-Wert
• Der FracUp-Wert

Wenn der Wert der Lippen größer ist als der Wert der Zähne und der Kiefer, der Wert der Zähne größer ist als der Wert der Kiefer, der Schlusskurs größer ist als der Wert der Zähne und der Wert von fracDown nicht gleich einem leeren Wert ist, soll das Handelssystem einen Kommentar auf dem Chart wie folgt ausgeben:

• Buy
• Jaws Value n
• Teeth Value n
• Lips Value n
• Fractals Low around: n

Im anderen Fall, wenn der Lippenwert niedriger ist als Zähne- und Kieferwert, die Zähne niedriger als der Kiefer, der Schlusskurs niedriger ist als die Zähne und der FracUp-Wert nicht leer ist, soll das Handelssystem Folgendes ausgeben:

• Sell
• Jaws Value n
• Teeth Value n
• Lips Value n
• Fractals High around: n

Das folgende Schaubild bezieht sich auf diese Blaupause:

Fraktale - Handelssystem

In diesem Thema werden wir lernen, wie man ein Handelssystem auf der Grundlage der genannten Strategien Schritt für Schritt erstellt, um sie im MetaTrader 5 Terminal auszuführen. Wir beginnen mit der Erstellung eines einfachen Fraktalsystems, das verwendet werden kann, um Kommentare auf dem Chart mit den Werten des Fraktalindikators zurückzugeben, und im Folgenden wird beschrieben, wie man das macht.

Erstellen von Arrays für Fraktale nach oben und unten unter Verwendung der Doppelfunktion.

   double fracUpArray[];
   double fracDownArray[];

Festlegen der Zugriffsrichtung der Daten mit der Funktion ArraySetAsSeries. Die Parameter sind:

• array[]: wir werden die erstellten Arrays fracUpArray und fracDownArray verwenden.
• flag: Wir verwenden true.

   ArraySetAsSeries(fracUpArray,true);
   ArraySetAsSeries(fracDownArray,true);

Definition des Fraktal-Indikators mit Hilfe der Funktion „iFractals“, die das Handle des Fraktal-Indikators zurückgibt. Die Parameter sind:

• symbol: Wir verwenden _Symbol für das aktuelle Symbol.
• period: Wir verwenden (_Period) für den aktuellen Zeitrahmen.

int fracDef=iFractals(_Symbol,_Period);

Abrufen von Daten und Speichern des Ergebnisses mit Hilfe der Funktion „CopyBuffer“. Die Parameter sind:

• indicator_handle: Die Variable des Indikator-Handles (fracDef).
• buffer_num: Um die Nummer des Indikatorpuffers zu bestimmen, wird (UPPER_LINE für fracUp), (LOWER_LINE für fracDown) verwendet.
• start_pos: Als Startposition verwenden wir 1.
• count: Die zu kopierenden Anzahl von Werten, wir benötigen 3.
• buffer[]: Um das zu kopierende Ziel-Array zu definieren, werden wir (fracUpArray, fracDownArray) verwenden.

   CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
   CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);

Werte der hohen und tiefen Fraktalen ermitteln.

   double fracUpValue=NormalizeDouble(fracUpArray[0],5);
   double fracDownValue=NormalizeDouble(fracDownArray[0],5);

Rückgabe des Wertes Null im Falle eines leeren Wertes für fracUpValue und faceDownValue.

   if(fracUpValue==EMPTY_VALUE)
      fracUpValue = 0;
   if(fracDownValue==EMPTY_VALUE)
      fracDownValue = 0;

Verwendung der Funktion „Comment“, um Kommentare auf dem Chart mit Werten der Fraktale zurückzugeben.

   Comment("Fractals Up Value = ",fracUpValue,"\n",
           "Fractals Down Value = ",fracDownValue);

Im Folgenden finden Sie den vollständigen Code zur Erstellung dieses Handelssystems.

//+------------------------------------------------------------------+
//|                                       Simple Fractals 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 fracUpArray[];
   double fracDownArray[];
//Sorting data
   ArraySetAsSeries(fracUpArray,true);
   ArraySetAsSeries(fracDownArray,true);
//define frac
   int fracDef=iFractals(_Symbol,_Period);
//define data and store result
   CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
   CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
//get values of fracUp and fracDown
   double fracUpValue=NormalizeDouble(fracUpArray[0],5);
   double fracDownValue=NormalizeDouble(fracDownArray[0],5);
//returning zero if there is empty value of fracUp
   if(fracUpValue==EMPTY_VALUE)
      fracUpValue = 0;
//returning zero if there is empty value of fracDown
   if(fracDownValue==EMPTY_VALUE)
      fracDownValue = 0;
//comment on the chart
   Comment("Fractals Up Value = ",fracUpValue,"\n",
           "Fractals Down Value = ",fracDownValue);
  }
//+------------------------------------------------------------------+

Nachdem wir diesen Code kompiliert haben, können wir ihn im Navigator von MetaTrader 5 wie folgt finden:

Durch Ziehen und Ablegen auf dem gewünschten Chart wird das Fenster wie folgt aussehen.

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 in der oberen rechten Ecke des Charts sehen können, ist der Experte angehängt und wir sind bereit, die gewünschten Signale zu empfangen, die folgenden Beispiele aus dem Test:

Wie wir in der oberen linken Ecke sehen können, haben wir zwei Werte:

• Fractals Up Value = n
• Fractals Down Value = 0

Und es ist klar, dass der Wert der Fraktale nach unten Null ist, da wir den Wert der Fraktale nach oben haben.

Wir haben zwei Werte:

• Fractals Up Value = 0
• Fractals Down Value = n

Aber der Wert der Fraktale nach oben ist Null, da wir den Wert der Fraktale nach unten haben.

1. Hohe und tiefe Fraktale

Im Folgenden finden Sie den vollständigen Code zur Erstellung eines Handelssystems für hohe und tiefe Fraktale.

//+------------------------------------------------------------------+
//|                                      Fractals highs and lows.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 arrays
   double fracUpArray[];
   double fracDownArray[];
//Sorting data
   ArraySetAsSeries(fracUpArray,true);
   ArraySetAsSeries(fracDownArray,true);
//define frac
   int fracDef = iFractals(_Symbol,_Period);
//define data and store result
   CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
   CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
//define values
   double fracUpValue = NormalizeDouble(fracUpArray[0],5);
   double fracDownValue = NormalizeDouble(fracDownArray[0],5);
//returning zero in case of empty values
   if(fracUpValue ==EMPTY_VALUE)
      fracUpValue = 0;
   if(fracDownValue ==EMPTY_VALUE)
      fracDownValue = 0;
//conditions of the strategy and comment on the chart with highs and lows
//in case of high
   if(fracUpValue>0)
     {
      Comment("Fractals High around: ",fracUpValue);
     }
//in case of low
   if(fracDownValue>0)
     {
      Comment("Fractals Low around: ",fracDownValue);
     }
  }
//+------------------------------------------------------------------+

Unterschiede in diesem Code.

Bedingungen der Strategie,

im Falle eines Verkaufs:

   if(fracUpValue>0)
     {
      Comment("Fractals High around: ",fracUpValue);
     }

im Falle eines Verkaufs:

   if(fracDownValue>0)
     {
      Comment("Fractals Low around: ",fracDownValue);
     }

Nachdem wir diesen Code kompiliert und auf dem Chart gestartet haben, wie wir es zuvor gelernt haben, werden wir feststellen, dass der Experte „Fractals highs and lows“ läuft:

Jetzt können wir die gewünschten Ergebnisse für Hohe und Tiefe erhalten. Im Falle von Tiefen:

Im vorherigen Chart sehen wir in der oberen linken Ecke, dass der Wert des Fraktal-Indikators ein Tief gebildet hat.

Im Falle von Hohen:

Wie wir sehen können, haben wir den hohen Wert des Fraktals, da der Indikator ein Hoch auf dem Chart gebildet hat.

2. Fraktale mit MA

Im Folgenden finden Sie den vollständigen Code zur Erstellung eines Handelssystems für die Strategie Fractals with MA.

//+------------------------------------------------------------------+
//|                                             Fractals with MA.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 arrays
   double fracUpArray[];
   double fracDownArray[];
   MqlRates priceArray[];
   double maArray[];
//Sorting data
   ArraySetAsSeries(fracUpArray,true);
   ArraySetAsSeries(fracDownArray,true);
   ArraySetAsSeries(priceArray,true);
   ArraySetAsSeries(maArray,true);
//define values
   int fracDef = iFractals(_Symbol,_Period);
   int Data = CopyRates(_Symbol,_Period,0,3,priceArray);
   int maDef = iMA(_Symbol,_Period,50,0,MODE_EMA,PRICE_CLOSE);
//define data and store result
   CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
   CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
   CopyBuffer(maDef,0,0,3,maArray);
//get values
   double fracUpValue = NormalizeDouble(fracUpArray[0],5);
   double fracDownValue = NormalizeDouble(fracDownArray[0],5);
   double closingPrice = priceArray[0].close;
   double maValue = NormalizeDouble(maArray[0],6);
   bool isBuy = false;
   bool isSell = false;
//conditions of the strategy and comment on the chart
//in case of buy
   if(closingPrice > maValue && fracDownValue != EMPTY_VALUE)
     {
      Comment("Buy","\n",
              "Current EMA: ",maValue,"\n",
              "Fractals Low around: ",fracDownValue);
      isBuy = true;
     }
//in case of sell
   if(closingPrice < maValue && fracUpValue != EMPTY_VALUE)
     {
      Comment("Sell","\n",
              "Current EMA: ",maValue,"\n",
              "Fractals High around: ",fracUpValue);
      isSell = true;
     }
  }
//+------------------------------------------------------------------+

Unterschiede in diesem Code.

Erstellung von zwei weiteren Arrays: priceArray mit der Funktion „MqlRates“ zur Speicherung von Informationen über Preise, Volumen und Spread und maArray mit der Funktion „double“.

   MqlRates priceArray[];
   double maArray[];

Sortieren von Daten aus diesen beiden Arrays.

   ArraySetAsSeries(priceArray,true);
   ArraySetAsSeries(maArray,true);

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

• symbol_name: 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 3.
• rates_array[]: Um das zu Zielarray zu bestimmen, wir verwenden priceArray.

Definition des gleitenden Durchschnitts mit Hilfe der Funktion „iMA“. Die Parameter:

• symbol: zur Bestimmung des Symbolnamens.
• period: zur Bestimmung der Periodenlänge.
• ma_period: Zur Bestimmung der Mittelungslänge, wir verwenden 50.
• ma_shift: Um die horizontale Verschiebung zu bestimmen, wir verwenden 0.
• ma_method: Um den Typ des gleitenden Durchschnitts zu bestimmen, wir verwenden EMA (Exponential Moving Average).
• applied_price: Zur Bestimmung des Preistyps, wir verwenden die Schlusskurse.

   int Data = CopyRates(_Symbol,_Period,0,3,priceArray);
   int maDef = iMA(_Symbol,_Period,50,0,MODE_EMA,PRICE_CLOSE);

Datenabruf.

CopyBuffer(maDef,0,0,3,maArray);

Abrufen des Schlusskurses und des MA-Wertes.

double closingPrice = priceArray[0].close;
double maValue = NormalizeDouble(maArray[0],6);

Erstellung von zwei bool-Variablen für Kauf (isBuy) und Verkauf (isSell), um Konflikte zwischen Kauf- und Verkaufssignalen der gleichen Kerze zu vermeiden.

   bool isBuy = false;
   bool isSell = false;

Bedingungen der Strategie.

Im Falle eines Kaufsignals:

   if(closingPrice > maValue && fracDownValue != EMPTY_VALUE)
     {
      Comment("Buy","\n",
              "Current EMA: ",maValue,"\n",
              "Fractals Low around: ",fracDownValue);
      isBuy = true;
     }

Im Falle eines Verkaufssignals:

   if(closingPrice < maValue && fracUpValue != EMPTY_VALUE)
     {
      Comment("Sell","\n",
              "Current EMA: ",maValue,"\n",
              "Fractals High around: ",fracUpValue);
      isSell = true;
     }

Nach dem Kompilieren und Ausführen dieses Codes läuft der EA Fractals with MA.

Wie wir in der oberen rechten Ecke sehen können, läuft der Experte Fractals with MA auf dem Chart. Wir werden die gewünschten Signale wie in den folgenden Beispielen erhalten:

Im Falle eines Kaufsignals:

Wir sehen einen Kommentar auf dem Chart mit Folgendem:

• Buy
• Current EMA
• Fractals Low around: n

Im Falle eines Verkaufssignals:

Wir sehen Folgendes:

• Sell
• Current EMA
• Fractals High around: n

3. Fraktale mit Alligator

Im Folgenden finden Sie den vollständigen Code zur Erstellung eines Handelssystems für die Strategie Fractals with Alligator.

//+------------------------------------------------------------------+
//|                                      Fractals with Alligator.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 arrays
   double fracUpArray[];
   double fracDownArray[];
   MqlRates priceArray[];
   double jawsArray[];
   double teethArray[];
   double lipsArray[];
//Sorting data
   ArraySetAsSeries(fracUpArray,true);
   ArraySetAsSeries(fracDownArray,true);
   ArraySetAsSeries(jawsArray,true);
   ArraySetAsSeries(teethArray,true);
   ArraySetAsSeries(lipsArray,true);
//define values
   int fracDef=iFractals(_Symbol,_Period);
   int Data = CopyRates(_Symbol,_Period,0,3,priceArray);
   int alligatorDef=iAlligator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);
//define data and store result
   CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
   CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
   CopyBuffer(alligatorDef,0,0,3,jawsArray);
   CopyBuffer(alligatorDef,1,0,3,teethArray);
   CopyBuffer(alligatorDef,2,0,3,lipsArray);
//get values
   double fracUpValue=NormalizeDouble(fracUpArray[0],5);
   double fracDownValue=NormalizeDouble(fracDownArray[0],5);
   double closingPrice = priceArray[0].close;
   double jawsValue=NormalizeDouble(jawsArray[0],5);
   double teethValue=NormalizeDouble(teethArray[0],5);
   double lipsValue=NormalizeDouble(lipsArray[0],5);
//creating bool variables to aviod buy ans sell signals at the same time
   bool isBuy = false;
   bool isSell = false;
//conditions of the strategy and comment on the chart
//in case of buy
   if(lipsValue>teethValue && lipsValue>jawsValue && teethValue>jawsValue
   && closingPrice > teethValue && fracDownValue != EMPTY_VALUE)
     {
      Comment("Buy","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue,"\n",
              "Fractals Low around: ",fracDownValue);
      isBuy = true;
     }
//in case of sell
   if(lipsValue<teethValue && lipsValue<jawsValue && teethValue<jawsValue
   && closingPrice < teethValue && fracUpValue != EMPTY_VALUE)
     {
      Comment("Sell","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue,"\n",
              "Fractals High around: ",fracUpValue);
      isSell = true;
     }
  }
//+------------------------------------------------------------------+

Unterschiede in diesem Code.

Erstellen von drei Arrays der Alligator-Komponenten.

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

Wir legen die Zugriffsrichtung der Daten in diesen Arrays mit Hilfe der Funktion „ArraySetAsSeries“ fest.

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

Definition des Alligators mit Hilfe der Funktion „iAlligator“. Die 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.
• jaw_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“. Die 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);

Abfrage der Werte der Alligator-Komponenten.

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

Bedingungen der Strategie,

Im Falle eines Kaufsignals:

   if(lipsValue>teethValue && lipsValue>jawsValue && teethValue>jawsValue
   && closingPrice > teethValue && fracDownValue != EMPTY_VALUE)
     {
      Comment("Buy","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue,"\n",
              "Fractals Low around: ",fracDownValue);
      isBuy = true;
     }

Im Falle eines Verkaufssignals:

   if(lipsValue<teethValue && lipsValue<jawsValue && teethValue<jawsValue
   && closingPrice < teethValue && fracUpValue != EMPTY_VALUE)
     {
      Comment("Sell","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue,"\n",
              "Fractals High around: ",fracUpValue);
      isSell = true;
     }

Nach dem Kompilieren dieses Codes und dem Ausführen im gewünschten Chart werden wir feststellen, dass der Experte auf dem Chart läuft:

Wir können die gewünschten Signale auf der Grundlage dieser Strategie erhalten, nachdem wir diesen Experten an das Chart angehängt haben, so wie wir es im vorherigen Chart in der oberen rechten Ecke sehen können.

Das Folgende sind Beispiele aus dem Testen von Signalen,

Im Falle eines Kaufsignals

Wie wir sehen können, haben wir die folgenden Werte als ein Signal auf dem vorherigen Chart in der oberen linken Ecke:

• Buy
• Jaws value
• Teeth value
• Lips value
• Fractals low value

Wir haben die folgenden Werte als Signal auf dem obigen Chart:

• Sell
• Jaws value
• Teeth value
• Lips value
• Fractals high value

Schlussfolgerung

Der technische Indikator Fraktale ist ein nützliches und effektives Instrument für den Handel, sei es als eigenständiges Instrument oder in Verbindung mit einem anderen technischen Indikator, da er nützliche Erkenntnisse liefert, wie wir in diesem Artikel erfahren haben. Es wird angenommen, dass Sie gelernt haben, was er ist, was er misst, wie er auf dem Chart durch die Methode seiner Berechnung gebildet werden kann und wie man den eingebauten auf dem MetaTrader 5 Terminal anzeigt. Darüber hinaus haben wir gelernt, wie wir sie durch die folgenden einfachen Handelsstrategien nutzen können:

• Hohe und tiefe Fraktale: um Hochs und Tiefs des Fraktal-Indikators zu erkennen und damit Signale auf dem Chart zu erhalten.
• Fraktale mit MA: Um Kauf- und Verkaufssignale zu erhalten, die auf generierten Fraktalsignalen gemäß der Position der Preise und ihres gleitenden Durchschnitts basieren.
• Fraktale mit Alligator: Um Kauf- und Verkaufssignale auf der Grundlage von Fraktalsignalen entsprechend der Position der Preise und des Alligator-Indikators zu erhalten.

Wir haben auch gelernt, wie wir ein Handelssystem erstellen können, das auf jeder der genannten Strategien basiert, um automatische Signale auf dem MetaTrader 5 Chart zu erhalten, indem wir diese Strategien mit MQL5 kodieren. Ich hoffe, dass Sie versuchen werden, sie selbst auszuprobieren, um ein tieferes Verständnis zu erlangen und mehr Einblicke in das Thema dieses Artikels oder in ein verwandtes Thema zu bekommen, um einen vollständigen Nutzen aus der Lektüre dieses Artikels zu ziehen.

Ich bestätige nochmals, dass Sie jede erwähnte Strategie testen müssen, bevor Sie sie auf Ihrem realen Konto anwenden, um sicherzustellen, dass sie profitabel ist. Ich hoffe, dass dieser Artikel für Sie nützlich war und Sie neue Dinge gelernt haben, die Ihre Handelsergebnisse verbessern können. Wenn Sie das gefunden haben und weitere ähnliche Artikel lesen möchten, können Sie meine anderen Artikel in dieser Serie über das Verständnis und die Erstellung eines Handelssystems auf der Grundlage der beliebtesten technischen Indikatoren lesen.