Aufbau und Test des Handelssystems Aroon

Einführung

Im Bereich des Handels und der technischen Analyse gibt es viele Werkzeuge, die wir verwenden können, aber wir werden sie sicherlich nicht alle verwenden und ein oder eine Kombination von profitablen Werkzeugen auswählen, nachdem wir sie getestet und optimiert haben. Der Zweck dieses Artikels ist es, eine Methode vorzustellen, die in diesem Zusammenhang hilfreich sein kann, oder Ihnen einen Einblick in eine andere Sichtweise oder eine Idee zu geben, die Sie anwenden können, um zu sehen, welches automatische Handelssystem zu Ihnen passt.

Diese Art von Artikel ist sehr hilfreich für Sie, weil Sie ihn in weniger Zeit lesen können als sie brauchen würden, um selbst ein gutes Setup eines Handelssystems zu finden. Aber Sie müssen doch noch arbeiten, nachdem Sie den für Sie interessant Weg herausgefunden haben. Sie müssen tiefer in die Materie eintauchen und optimieren, bis Sie die ultimativen Ergebnisse erreichen, die Ihren Handel profitabel machen könnten. Wir versuchen hier lediglich, Handelsinstrumente vorzustellen, die einzeln oder in Kombination mit anderen Hilfsmitteln verwendet werden können, um Ihnen Zeit zu sparen, wenn Sie herausfinden wollen, worauf Sie sich konzentrieren müssen, um es zu Ihren Gunsten weiterzuentwickeln. Außerdem wird erläutert, wie diese Systeme für die Prüfung mit dem Strategy Tester kodiert werden können, was bedeutet, dass Sie viel Zeit sparen können, indem Sie Ihren Prüfprozess automatisieren, anstatt manuell zu prüfen.

In diesem Artikel werden wir den technischen Indikator Aroon verwenden und wir werden mehr als eine Strategie auf der Grundlage seiner Konzepte testen und ihre Ergebnisse sehen, was viel wertvoller sein wird, ist, dass wir lernen werden, wie wir den Indikator von MQL5 kodieren und ihn in unserem Handelssystem auf der Grundlage der Strategie verwenden können. All dies wird geschehen, nachdem wir gelernt haben, was der Aroon-Indikator ist und wie wir ihn berechnen und verwenden können.

In diesem Artikel werden die folgenden Themen behandelt:

• Definition des Indikators Aroon
• Aroon-Strategien
• Aroon Handelssysteme
• Prüfung der Aroon-Handelssysteme
• Schlussfolgerung

Nach den vorangegangenen Themen werden wir in der Lage sein, viel mehr über den Aroon-Indikator zu verstehen, wie wir ihn verwenden können, was wir für den Aufbau eines Handelssystems benötigen, Aroon-Handelsstrategien, den Aufbau von Handelssystemen, die auf diesen Strategien basieren, und das Testen dieser Strategien, um zu sehen, inwieweit sie beim Handel nützlich sind.

Es ist wichtig, hier zu erwähnen, dass Sie Ihre Tests mit verschiedenen Perspektiven durchführen müssen, um die besten und besseren Ergebnisse zu erzielen, die zu Ihrem Handelsstil oder Ihrem Handelssystem passen, wenn Sie ein Tool zu Ihrem bestehenden Handelssystem hinzufügen wollen, da ich hier nicht alle Perspektiven aufzeigen kann, da jeder Mensch anders ist und keine Strategie oder kein Handelssystem für alle Händler geeignet ist, aber ich kann einen Teil davon beisteuern, was Ihnen helfen kann, etwas Zeit bei Ihrer Arbeit zu sparen.

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.

Definition des Indikators Aroon

In diesem Teil werden wir den technischen Indikator Aroon identifizieren, um sein Hauptkonzept zu verstehen. Wir werden verstehen, wie dieser Indikator berechnet werden kann, und dieser Ansatz kann für unser Ziel hilfreich sein, das Hauptkonzept des Indikators zu verstehen und nicht nur das zu verwenden, was erwähnt wird, sondern in der Lage zu sein, unseren Ansatz zu entwickeln, um ihn angemessen zu verwenden.

Der Aroon wurde 1995 von Tushar S. Chande entworfen und gestaltet. Die Hauptidee des Indikators besteht darin, die Trendänderung zu erkennen und auch die Stärke des Trends zu messen. Der Indikator kann dies tun, indem er misst, wie viel Zeit zwischen den Höchstständen und wie viel Zeit zwischen den Tiefstständen über einen bestimmten Zeitraum vergangen ist. Wenn wir dies messen, können wir sagen, dass der starke Aufwärtstrend darin besteht, dass er regelmäßig neue Höchststände erreicht, während der starke Abwärtstrend darin besteht, dass er regelmäßig neue Tiefststände erreicht, und der Indikator gibt uns dafür Signale.

Der Aroon-Indikator besteht aus zwei Linien, dem Aroon Up, der die Stärke des Aufwärtstrends misst, und dem Aroon Down, der die Stärke des Abwärtstrends misst. In diesem Zusammenhang können wir sagen, dass, wenn der Aroon Up über dem Aroon Down liegt, dies ein bullisches Signal darstellt. Wenn der Aroon Down über dem Aroon Up liegt, ist dies ein Abwärtssignal. Die Aroon-Indikatoren bewegen sich ebenfalls zwischen den Werten Null und 100.

Im Folgenden erfahren Sie, wie Sie den technischen Indikator Aroon berechnen können:

Aroon Up = 100 * ((n-H)/n)

Aroon Down = 100 * ((n-L)/n)

Wobei:

• Aroon Up: Ausgedrückt als Prozentsatz der Gesamtzahl der n-Perioden, stellt er die Anzahl der Perioden seit dem letzten n-Perioden-Hoch dar.
• Aroon Down: Ausgedrückt als Prozentsatz der Gesamtzahl der n-Perioden, stellt er die Anzahl der Perioden seit dem letzten n-Perioden-Tief dar.
• H: die Anzahl der Perioden innerhalb eines bestimmten Zeitraums von n Perioden seit dem letzten n-Perioden-Hoch.
• L: die Anzahl der Perioden innerhalb einer bestimmten Zeitspanne von n Perioden seit dem letzten n-Perioden-Tief.
• n: der Zeitraum.

Aroon-Strategien

In diesem Teil werden wir zwei einfache Strategien zur Verwendung des Aroon-Indikators auf der Grundlage seines Konzepts vorstellen. Diese Strategien werden auch von MQL5 kodiert, um vom Strategietester getestet zu werden und die Ergebnisse jedes einzelnen zu sehen und zwischen ihnen zu vergleichen, genauso wie wir es im Thema Testen von Aroon Handelssystemen sehen werden.

Wir werden zwei Hauptstrategien anwenden, die den folgenden entsprechen:

• Aroon Crossover Strategie
• Aroon Levels Strategie

Aroon Crossover Strategie:

Auf der Grundlage dieser Strategie müssen wir die Aufträge platzieren, wenn die Aufwärts- und Abwärtslinien des Aroon-Indikators einander kreuzen. Wir müssen also einen Kaufauftrag erteilen, wenn wir sehen, dass der Crossover der Aufwärtslinie über der Abwärtslinie liegt, und einen Verkaufsauftrag erteilen, wenn wir sehen, dass der Crossover der Abwärtslinie über der Aufwärtslinie liegt.

Upline > Downline ==> kaufen

Downline > Upline ==> verkaufen

Aroon Level Strategie:

Auf der Grundlage dieser Strategie müssen wir die Aufträge platzieren, wenn die Abwärtslinie des Aroon-Indikators eine Kreuzung mit den Niveaus 10 und 50 des Aroon-Indikators bildet. Wir müssen also einen Kaufauftrag erteilen, wenn wir sehen, dass der Crossover der Abwärtslinie unter der 10er-Marke liegt, und einen Verkaufsauftrag erteilen, wenn wir sehen, dass der Crossover der Abwärtslinie über der 50er-Marke des Aroon-Indikators liegt.

Downline < 10 ==> kaufen

Downline > 50 ==> verkaufen

Aroon Handelssysteme

In diesem Teil werden wir lernen, wie man die erwähnten Aroon-Strategien in MQL5 kodiert, um sie mit dem Tester zu testen und ihre Ergebnisse auszuwerten. Zunächst müssen wir unseren nutzerdefinierten Aroon-Indikator codieren, um ihn in unseren Handelsstrategien verwenden zu können (siehe unten):

Wir setzen im globalen Bereich von MQL5 die Eigenschaften der Indikatoren mit Hilfe der Eigenschaften des Präprozessors:

//properties of the indicator
#property indicator_separate_window // the place of the indicator
#property indicator_buffers 2 // number of buffers
#property indicator_plots 2 // number of plots

//up line
#property indicator_type1  DRAW_LINE      // type of the up values to be drawn is a line
#property indicator_color1 clrGreen       // up line color
#property indicator_style1 STYLE_DASH     // up line style
#property indicator_width1 2              // up line width
#property indicator_label1 "Up"           // up line label

// down line
#property indicator_type2  DRAW_LINE      // type of the down values to be drawn is a line
#property indicator_color2 clrRed         // down line color
#property indicator_style2 STYLE_DASH     // down line style
#property indicator_width2 2              // down line width
#property indicator_label2 "Down"         // down line label

// drawing some levels to be used later 10 and 50
#property indicator_level1 10.0
#property indicator_level2 50.0
#property indicator_levelcolor clrSilver
#property indicator_levelstyle STYLE_DOT

Wir erstellen von zwei ganzzahligen Eingaben für den Indikator, nämlich die Periode und die horizontale Verschiebung, mit Hilfe des Schlüsselworts input:

//inputs
input int                      periodInp = 25; // Period
input int                      shiftInp  = 0;  // horizontal shift

Wir erstellen von zwei Double-Arrays für die Auf- und Abwärtswerte des Indikators:

//buffers of the indicator
double                         upBuffer[];
double                         downBuffer[];

In OnInit() wird die Funktion SetIndexBuffer verwendet, um die Indikatorpuffer mit den Double-Arrays zu verknüpfen, die Parameter sind:

• index: zur Angabe des Pufferindexes wird 0 für den upBuffer und 1 für den downBuffer verwendet.
• buffer[]: Um das Array zu spezifizieren, werden die Arrays upBuffer und downBuffer verwendet.
• data_type: zur Angabe des Datentyps, der gespeichert werden soll, wobei es sich um einen der ENUM_INDEXBUFFR_TYPE handeln kann; wir verwenden INDICATOR_DATA sowohl für auf- als auch für abwärts.

   SetIndexBuffer(0, upBuffer, INDICATOR_DATA);
   SetIndexBuffer(1, downBuffer, INDICATOR_DATA);

Einstellung der Werte der entsprechenden Eigenschaft und der entsprechenden Indikatorlinien von oben und unten durch Verwendung der Funktion PlotIndexSetInteger unter Verwendung der Variante des Aufrufs, die den Bezeichner der Eigenschaft angibt, und die Parameter sind die gleichen wie die folgenden:

• plot_index: ist ein ganzzahliger Wert für den Index des Zeichenstils, der 0 für „up“ und 1 für „down“ ist.
• prop_id:: ist ein ganzzahliger Wert des Eigenschaftsbezeichners, er kann einer der ENUM_PLOT_PROPERTY_INTEGER sein. Wir werden PLOT_SHIFT für die Auf- und Abwärtswerte verwenden. Wir werden PLOT_DRAW_BEGIN für Auf- und Abwärts.
• prop_value: ist ein zu setzender Integer-Wert, der shiftInp für oben und unten, periodInp für oben und unten ist.

   PlotIndexSetInteger(0, PLOT_SHIFT, shiftInp);
   PlotIndexSetInteger(1, PLOT_SHIFT, shiftInp);
   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, periodInp);
   PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, periodInp);

Setzen des AS_SERIES-Flags auf Arrays für Aufwärts- und Abwärtsbewegungen:

   ArraySetAsSeries(upBuffer, true);
   ArraySetAsSeries(downBuffer, true);

Einstellen des String-Namens und der Integer-Werte des Indikators nach der Deklaration einer String-Variablen mit dem Namen indicatorName und der Zuweisung der Funktion StringFormat, um das Format für die Anzeige im Indikatorfenster festzulegen:

   string indicatorName = StringFormat("Aroon Indicator (%i,%i) - ", periodInp, shiftInp);
   IndicatorSetString(INDICATOR_SHORTNAME, indicatorName);
   IndicatorSetInteger(INDICATOR_DIGITS, 0);

Rückgabe von INIT_SUCCEEDED zur Beendigung von OnInit():

return INIT_SUCCEEDED;

OnCalculate:

int OnCalculate(const int       rates_total,
                const int       prev_calculated,
                const datetime &time[],
                const double   &open[],
                const double   &high[],
                const double   &low[],
                const double   &close[],
                const long     &tick_volume[],
                const long     &volume[],
                const int      &spread[])

Im Hauptteil des Ereignisses wird der Indikator berechnet und 0 zurückgegeben, wenn nicht genügend Daten vorhanden sind:

   if(rates_total < periodInp - 1)
      return (0);

Erstellung einer ganzzahligen Zählvariablen und Berechnung als Ergebnis der Subtraktion von rate_total und prev_calculated

int count = rates_total - prev_calculated;

Wenn prev_calculated größer als 0 ist, was bedeutet, dass wir neue Daten haben, werden wir die Zählung aktualisieren, indem wir 1 hinzufügen:

   if(prev_calculated > 0)
      count++;

Erstellen einer weiteren Bedingung zur Aktualisierung des Zählwerts:

   if(count > (rates_total - periodInp + 1))
      count = (rates_total - periodInp + 1);

Erstellen einer for-Schleife zur Berechnung und Aktualisierung der Werte von up und down des Indikators nach Berechnung der höchsten und niedrigsten Werte:

   for(int i = count - 1; i >= 0; i--)
     {
      int highestVal   = iHighest(Symbol(), Period(), MODE_HIGH, periodInp, i);
      int lowestVal    = iLowest(Symbol(), Period(), MODE_LOW, periodInp, i);
      upBuffer[i]   = (periodInp - (highestVal - i)) * 100 / periodInp;
      downBuffer[i] = (periodInp - (lowestVal - i)) * 100 / periodInp;
     }

Rückgabe von rate_total als Teil des OnCalculate-Ereignisses:

return (rates_total);

Im Folgenden finden Sie den vollständigen Code zur Erstellung unseres nutzerdefinierten Aroon-Indikators in einem einzigen Codeblock:

//+------------------------------------------------------------------+
//|                                                        Aroon.mq5 |
//+------------------------------------------------------------------+
#property indicator_separate_window // the place of the indicator
#property indicator_buffers 2 // number of buffers
#property indicator_plots 2 // number of plots
#property indicator_type1  DRAW_LINE      // type of the up values to be drawn is a line
#property indicator_color1 clrGreen       // up line color
#property indicator_style1 STYLE_DASH     // up line style
#property indicator_width1 2              // up line width
#property indicator_label1 "Up"           // up line label
#property indicator_type2  DRAW_LINE      // type of the down values to be drawn is a line
#property indicator_color2 clrRed         // down line color
#property indicator_style2 STYLE_DASH     // down line style
#property indicator_width2 2              // down line width
#property indicator_label2 "Down"         // down line label
#property indicator_level1 10.0
#property indicator_level2 50.0
#property indicator_levelcolor clrSilver
#property indicator_levelstyle STYLE_DOT
input int periodInp = 25; // Period
input int shiftInp  = 0;  // horizontal shift
double    upBuffer[];
double    downBuffer[];
int OnInit()
  {
   SetIndexBuffer(0, upBuffer, INDICATOR_DATA);
   SetIndexBuffer(1, downBuffer, INDICATOR_DATA);
   PlotIndexSetInteger(0, PLOT_SHIFT, shiftInp);
   PlotIndexSetInteger(1, PLOT_SHIFT, shiftInp);
   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, periodInp);
   PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, periodInp);
   ArraySetAsSeries(upBuffer, true);
   ArraySetAsSeries(downBuffer, true);
   string indicatorName = StringFormat("Aroon Indicator (%i,%i) - ", periodInp, shiftInp);
   IndicatorSetString(INDICATOR_SHORTNAME, indicatorName);
   IndicatorSetInteger(INDICATOR_DIGITS, 0);
   return INIT_SUCCEEDED;
  }
int OnCalculate(const int       rates_total,
                const int       prev_calculated,
                const datetime &time[],
                const double   &open[],
                const double   &high[],
                const double   &low[],
                const double   &close[],
                const long     &tick_volume[],
                const long     &volume[],
                const int      &spread[])
  {
   if(rates_total < periodInp - 1)
      return (0);
   int count = rates_total - prev_calculated;
   if(prev_calculated > 0)
      count++;
   if(count > (rates_total - periodInp + 1))
      count = (rates_total - periodInp + 1);
   for(int i = count - 1; i >= 0; i--)
     {
      int highestVal   = iHighest(Symbol(), Period(), MODE_HIGH, periodInp, i);
      int lowestVal    = iLowest(Symbol(), Period(), MODE_LOW, periodInp, i);
      upBuffer[i]   = (periodInp - (highestVal - i)) * 100 / periodInp;
      downBuffer[i] = (periodInp - (lowestVal - i)) * 100 / periodInp;
     }
   return (rates_total);
  }
//+------------------------------------------------------------------+

Nach dem Kompilieren dieses Codes wird unser nutzerdefinierter Indikator beim Einfügen in das Chart so aussehen wie die folgende Grafik:

Nachdem wir unseren nutzerdefinierten Indikator erstellt haben, sind wir bereit, unsere Handelsstrategien zu entwickeln. Wir werden also mit der Ersten beginnen, dem Aroon-Crossover, dann den Aroon-Levels, aber vorher werden wir ein einfaches Programm erstellen, das die Aroon-Werte nach oben und unten anzeigen kann, und das Folgende ist eine Methode dafür.

Zunächst erstellen wir im globalen Bereich mit dem Schlüsselwort input zwei Nutzereingaben für die Periode und die Verschiebung:

input int         periodInp = 25; // Period
input int         shiftInp  = 0; // Shift

Wir deklarieren eine Integer-Variable für Aroon, um ihm später den Indikator-Handle zuzuweisen:

int aroon;

In OnInit() werden wir mit der Funktion iCustom das Handle des Aroon Indikators im EA mit folgenden Parametern erstellen:

• Symbol: um den Namen des Symbols anzugeben, und wir werden _Symbol verwenden, um das aktuelle Symbol zurückzugeben.
• Periode: um die Periode anzugeben, und wir werden _Period verwenden, um auch die aktuelle Periode zurückzugeben.
• Name: um den genauen Namen Ihres nutzerdefinierten Indikators mit seinem genauen Verzeichnis oder Pfad im Ordner Indicators anzugeben,
• ... dann geben wir die Liste der Eingabeparameter des nutzerdefinierten Indikators an. Wir werden nur unsere beiden erstellten Eingaben (Periode und Verschiebung) verwenden.

aroon = iCustom(_Symbol,PERIOD_CURRENT,"Aroon",periodInp,shiftInp);

Geben Sie dann die Meldung (INIT_SUCCEEDED) zurück, wenn der EA erfolgreich initialisiert wurde:

return(INIT_SUCCEEDED);

In OnDeinit drucken wir Print("EA is removed"), wenn das Ereignis Deinit eintritt, um das laufende MQL5-Programm zu deinitialisieren:

void OnDeinit(const int reason)
  {
   Print("EA is removed");
  }

In OnTick() deklarieren wir zwei Double-Arrays von upBuffer und downBuffer:

double upBuffer[], downBuffer[];

Abrufen der erstellten Pufferdaten des Aroon-Indikators mit Hilfe der Funktion CopyBuffer mit der Variante des Aufrufs nach der ersten Position und der Anzahl der erforderlichen Elemente und deren Parameter sind:

• indicator_handle: für das Handle des Aroon-Indikators.
• buffer_num: die Puffernummer des Indikators.
• start_pos: zur Angabe der Startposition.
• count: zur Angabe der Anzahl ab start_pos.
• buffer[]: die Datenpuffer.

   CopyBuffer(aroon,0,0,3,upBuffer);
   CopyBuffer(aroon,1,0,3,downBuffer);

Mit der ArraySetAsSeries wird das AS_SERIES-Flag auf das angegebene Flag gesetzt, das wahr ist, um die Indizierung der Arrays umzukehren:

   ArraySetAsSeries(upBuffer,true);
   ArraySetAsSeries(downBuffer,true);

Deklaration von zwei Double-Variablen upValue und downValue zur Zuweisung der aktuellen Werte des Aroon-Indikators aus Arrays durch Indizierung [0]:

   double upValue = upBuffer[0];
   double downValue = downBuffer[0];

Mit der Funktion Comment() können wir einen Kommentar zum Chart mit den Auf- und Abwärtswerten des Aroon-Indikators ausgeben:

Comment("upValue: ",upValue,"\ndownValue: ",downValue);

Im Folgenden finden Sie den vollständigen Code in einem Block, um dies zu tun:

//+------------------------------------------------------------------+
//|                                                AroonValuesEA.mq5 |
//+------------------------------------------------------------------+
input int         periodInp = 25; // Period
input int         shiftInp  = 0; // Shift
int aroon;
int OnInit()
  {
   aroon = iCustom(_Symbol,PERIOD_CURRENT,"Aroon",periodInp,shiftInp);
   return(INIT_SUCCEEDED);
  }
void OnDeinit(const int reason)
  {
   Print("EA is removed");
  }
void OnTick()
  {
   double upBuffer[], downBuffer[];
   CopyBuffer(aroon,0,0,3,upBuffer);
   CopyBuffer(aroon,1,0,3,downBuffer);
   ArraySetAsSeries(upBuffer,true);
   ArraySetAsSeries(downBuffer,true);
   double upValue = upBuffer[0];
   double downValue = downBuffer[0];
   Comment("upValue: ",upValue,"\ndownValue: ",downValue);
  }
//+------------------------------------------------------------------+

Nach dem fehlerfreien Kompilieren des Codes und dem Ausführen des EA auf dem Chart können wir die gleiche Ausgabe wie im folgenden Beispiel finden:

Wie wir im vorherigen Chart sehen können, finden wir die Aufwärts- und Abwärtswerte als Kommentar, und wir können auch den erstellten nutzerdefinierten Indikator in das Chart eingefügt finden, um sicherzustellen, dass der EA die gleichen Werte des Indikators (96, 48) zurückgibt.

Die Crossover-Strategie von Aroon:

Nun ist es an der Zeit, unsere erwähnten Handelsstrategien zu codieren. Wir beginnen mit der Aroon-Crossover-Strategie.

Im globalen Bereich werden wir den #include-Präprozessor verwenden, um Handelsfunktionen in unseren EA einzubinden, die automatisch Aufträge auf der Grundlage unserer Strategie platzieren:

#include <trade/trade.mqh>

Erstellen von fünf Eingängen Periode, horizontale Verschiebung, lotSize, slLvl und tpLvl und Zuweisen von Standardwerten für jeden:

input int         periodInp = 25; // Period
input int         shiftInp  = 0; // Shift
input double      lotSize=1;
input double      slLvl=200;
input double      tpLvl=600;

Wir erstellen folgende Variablen:

• Die ganzzahlige Variable aroon, die später für die Definition des Indikators verwendet wird.
• Die ganzzahlige Variable barstotal, um die Eröffnungsaufträge für jeden Balken zu begrenzen.
• Ein CTrade-Handelsobjekt, das bei der Auftragserteilung verwendet wird.

int aroon;
int barsTotal;
CTrade trade;

In OnInit() weisen wir der deklarierte Variable barsTotal mit der Funktion iBars die verfügbaren Bars des Symbols und der Periode in der Historie zu:

barsTotal=iBars(_Symbol,PERIOD_CURRENT);

Der Variablen aroon weisen wir mit der Funktion iCustom das Handle des Indikators zu:

aroon = iCustom(_Symbol,PERIOD_CURRENT,"Aroon",periodInp,shiftInp);

In OnDeinit() werden wir ausgeben, das der EA beendet wurde:

Print("EA is removed");

In OnTick() wird die Integer-Variable bars deklariert, um den Index des Balken für jeden Tick zu speichern:

int bars=iBars(_Symbol,PERIOD_CURRENT);

Prüfen, ob barsTotal nicht gleich den bars ist

if(barsTotal != bars)

Dann aktualisieren wir barsTotal mit bars:

barsTotal=bars;

Wir deklarieren zwei Double-Arrays für Auf- und Abwerte, rufen die Daten aus den Puffern des Indikators ab, setzen das Flag AS_SERIES für das ausgewählte Array, deklarieren und definieren von vier Double-Variablen für vorherige und aktuelle Auf- und Abwerte:

      double upBuffer[], downBuffer[];
      CopyBuffer(aroon,0,0,3,upBuffer);
      CopyBuffer(aroon,1,0,3,downBuffer);
      ArraySetAsSeries(upBuffer,true);
      ArraySetAsSeries(downBuffer,true);
      double prevUpValue = upBuffer[1];
      double prevDownValue = downBuffer[1];
      double upValue = upBuffer[0];
      double downValue = downBuffer[0];

Dann werden die Bedingungen für einen Kaufauftrag festgelegt, d.h. der prevUpValue muss kleiner als der prevDownValue sein und gleichzeitig muss der upValue größer als der downValue sein:

if(prevUpValue<prevDownValue && upValue>downValue)

Wenn diese Bedingung erfüllt ist, wird eine Double-Variable für Ask deklariert und als aktueller Ask-Kurs des aktuellen Symbols definiert, die Double-Werte slVal und tpVal deklariert und definiert und eine Kaufposition mit der vordefinierten lotSize durch den Nutzer des aktuellen Symbols zum aktuellen Ask-Kurs platziert, Stop-Loss ist der vordefinierte Wert von slVal sein und Take-Profit ist der vordefinierte Wert von tpVal:

         double ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
         double slVal=ask - slLvl*_Point;
         double tpVal=ask + tpLvl*_Point;
         trade.Buy(lotSize,_Symbol,ask,slVal,tpVal);

Dann werden die Bedingungen für den Verkaufsauftrag festgelegt, die darin bestehen, dass der prevUpValue größer als der prevDownValue ist und gleichzeitig der upValue kleiner als der downValue ist:

if(prevUpValue>prevDownValue && upValue<downValue)

Wenn diese Bedingung erfüllt ist, wird eine Double-Variable für den Bid-Kurs deklariert und als aktueller Bid-Kurs des aktuellen Symbols definiert, die Double-Werte slVal und tpVal deklariert und definiert und eine Verkaufsposition mit der vordefinierten lotSize durch den Nutzer des aktuellen Symbols zum aktuellen Bid-Kurs platziert, Stop-Loss ist der vordefinierte Wert von slVal sein und Take-Profit ist der vordefinierte Wert von tpVal:

         double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
         double slVal=bid + slLvl*_Point;
         double tpVal=bid - tpLvl*_Point;
         trade.Sell(lotSize,_Symbol,bid,slVal,tpVal);

Im Folgenden finden Sie den vollständigen Code für die Aroon-Crossover-Strategie in einem einzigen Block:

//+------------------------------------------------------------------+
//|                                             AroonCrossoverEA.mq5 |
//+------------------------------------------------------------------+
#include <trade/trade.mqh>
input int         periodInp = 25; // Period
input int         shiftInp  = 0; // Shift
input double      lotSize=1;
input double      slLvl=200;
input double      tpLvl=600;
int aroon;
int barsTotal;
CTrade trade;
int OnInit()
  {
   barsTotal=iBars(_Symbol,PERIOD_CURRENT);
   aroon = iCustom(_Symbol,PERIOD_CURRENT,"Aroon",periodInp,shiftInp);
   return(INIT_SUCCEEDED);
  }
void OnDeinit(const int reason)
  {
   Print("EA is removed");
  }
void OnTick()
  {
   int bars=iBars(_Symbol,PERIOD_CURRENT);
   if(barsTotal != bars)
     {
      barsTotal=bars;
      double upBuffer[], downBuffer[];
      CopyBuffer(aroon,0,0,3,upBuffer);
      CopyBuffer(aroon,1,0,3,downBuffer);
      ArraySetAsSeries(upBuffer,true);
      ArraySetAsSeries(downBuffer,true);
      double prevUpValue = upBuffer[1];
      double prevDownValue = downBuffer[1];
      double upValue = upBuffer[0];
      double downValue = downBuffer[0];
      if(prevUpValue<prevDownValue && upValue>downValue)
        {
         double ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
         double slVal=ask - slLvl*_Point;
         double tpVal=ask + tpLvl*_Point;
         trade.Buy(lotSize,_Symbol,ask,slVal,tpVal);
        }
      if(prevUpValue>prevDownValue && upValue<downValue)
        {
         double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
         double slVal=bid + slLvl*_Point;
         double tpVal=bid - tpLvl*_Point;
         trade.Sell(lotSize,_Symbol,bid,slVal,tpVal);
        }
     }
  }
//+------------------------------------------------------------------+

Nach der fehlerfreien Kompilierung dieses Codes können wir Beispiele für die Platzierung von Aufträgen auf der Grundlage der Strategie wie die folgenden finden:

Beispiel für einen Kaufauftrag:

Wie im vorangegangenen Beispiel zu sehen ist, haben wir einen Kaufauftrag nach dem Kreuzen der Aufwärts- und Abwärtslinien.

Beispiel für einen Verkaufsauftrag:

Wie wir im vorherigen Beispiel sehen können, haben wir einen Verkaufsauftrag erteilt, nachdem die Abwärtslinie den Crossover mit der Aufwärtslinie nach oben gemacht hat.

Die Strategie der Aroon-Ebenen:

In diesem Teil werden wir die erwähnte Aroon-Levels-Strategie kodieren, die es dem EA ermöglicht, einen Auftrag zu senden, wenn es zu einem Kreuzen der Abwärtslinie und den 10- und 50-Levels des Aroon-Indikators selbst basiert. Im Folgenden wird beschrieben, wie wir es in MQL5 kodieren können. Er ist ähnlich der Aroon Crossover-Strategie, sodass wir den vollständigen Code zur Verfügung stellen und nur die Unterschiede zwischen diesem Code und dem vorherigen Code der Aroon Crossover-Strategie erwähnen werden.

Im Folgenden finden Sie den vollständigen Code für die Aroon-Level-Strategie in einem einzigen Codeblock:

//+------------------------------------------------------------------+
//|                                                AroonLevelsEA.mq5 |
//+------------------------------------------------------------------+
#include <trade/trade.mqh>
input int         periodInp = 25; // Period
input int         shiftInp  = 0; // Shift
input double      lotSize=1;
input double      slLvl=200;
input double      tpLvl=600;
int aroon;
int barsTotal;
CTrade trade;
int OnInit()
  {
   barsTotal=iBars(_Symbol,PERIOD_CURRENT);
   aroon = iCustom(_Symbol,PERIOD_CURRENT,"Aroon",periodInp,shiftInp);
   return(INIT_SUCCEEDED);
  }
void OnDeinit(const int reason)
  {
   Print("EA is removed");
  }
void OnTick()
  {
   int bars=iBars(_Symbol,PERIOD_CURRENT);
   if(barsTotal != bars)
     {
      barsTotal=bars;
      double upBuffer[], downBuffer[];
      CopyBuffer(aroon,0,0,3,upBuffer);
      CopyBuffer(aroon,1,0,3,downBuffer);
      ArraySetAsSeries(upBuffer,true);
      ArraySetAsSeries(downBuffer,true);
      double prevDownValue = downBuffer[1];
      double downValue = downBuffer[0];
      if(prevDownValue> 10 && downValue<10)
        {
         double ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
         double slVal=ask - slLvl*_Point;
         double tpVal=ask + tpLvl*_Point;
         trade.Buy(lotSize,_Symbol,ask,slVal,tpVal);
        }
      if(prevDownValue < 50 && downValue>50)
        {
         double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
         double slVal=bid + slLvl*_Point;
         double tpVal=bid - tpLvl*_Point;
         trade.Sell(lotSize,_Symbol,bid,slVal,tpVal);
        }
     }
  }

Unterschiede in diesem Code sind die gleichen wie die folgenden.

Wir müssen nur den vorherigen und den aktuellen Wert definieren:

      double prevDownValue = downBuffer[1];
      double downValue = downBuffer[0];

Bedingung der Strategie, wenn der prevDownValue größer als die 10er-Marke ist und gleichzeitig der aktuelle downValue kleiner als der Level 10 ist. Wir brauchen den EA, um einen Kaufauftrag zu platzieren, nachdem wir den Ask, Stop-Loss und Take-Profit definiert haben:

      if(prevDownValue> 10 && downValue<10)
        {
         double ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
         double slVal=ask - slLvl*_Point;
         double tpVal=ask + tpLvl*_Point;
         trade.Buy(lotSize,_Symbol,ask,slVal,tpVal);
        }

Wenn der prevDownValue kleiner als der Wert 50 ist und gleichzeitig der aktuelle downValue größer als der Wert 50 ist. Wir brauchen den EA, um einen Verkaufsauftrag zu platzieren, nachdem wir das aktuelle Angebot, den Stop-Loss und den Take-Profit definiert haben:

      if(prevDownValue < 50 && downValue>50)
        {
         double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
         double slVal=bid + slLvl*_Point;
         double tpVal=bid - tpLvl*_Point;
         trade.Sell(lotSize,_Symbol,bid,slVal,tpVal);
        }

Nach dem fehlerfreien Kompilieren dieses Codes können wir feststellen, dass der EA die gleichen Aufträge wie in den folgenden Beispielen platzieren kann.

Beispiel für einen Kaufauftrag:

Beispiel für einen Verkaufsauftrag:

Prüfung des Aroon-Handelssystems

In diesem Teil werden wir jede Strategie testen, um ihre Ergebnisse zu sehen, und ich kann nicht genug bestätigen, dass sie möglicherweise mehr Optimierungen für diese Strategien benötigen, um bessere Ergebnisse zu erzielen. Sie müssen Ihre Hausaufgaben machen, um zu sehen, was zu Ihrem Weg passt oder was mehr wertvoll sein kann. 

Wir werden uns auf die folgenden Schlüsselmessungen konzentrieren, um einen Vergleich zwischen den beiden durchzuführen:

• Nettogewinn (NetProfit): Dieser wird berechnet, indem der Bruttoverlust vom Bruttogewinn abgezogen wird. Der höchste Wert ist der beste.
• Salden-DD relativ:  Dies ist der maximale Verlust, den das Konto während des Handels erfahren kann. Je niedriger, desto besser.
• Gewinnfaktor:  Dies ist das Verhältnis von Bruttogewinn zu Bruttoverlust. Je höher, desto besser.
• Erwartete Auszahlung:  Das ist der durchschnittliche Gewinn oder Verlust eines Handelsgeschäfts. Je höher, desto besser.
• Erholungsfaktor:  Dieser misst, wie gut sich die getestete Strategie nach Verlusten wieder erholen wird. Je höher, desto besser.
• Sharpe Ratio: Sie bestimmt das Risiko und die Stabilität des getesteten Handelssystems, indem sie die Rendite mit der risikofreien Rendite vergleicht. Die höchste Sharpe Ratio ist die beste.

Wir werden auch den gleichen Zeitraum testen, wenn wir beide Strategien testen. Der Zeitraum ist ein Jahr vom 1. Januar 2023 bis zum 31. Dezember 2023 und wir werden zwei Zeitrahmen testen, 15 Minuten und eine Stunde.

Die Crossover-Strategie von Aroon:

Jetzt werden wir die Ergebnisse der Aroon Crossover-Strategie mit zwei Zeitrahmen, 15 Minuten und 1 Stunde, betrachten, um zu sehen, welche besser ist, basierend auf dem, worauf wir uns bei den zuvor erwähnten Zahlen konzentrieren werden.

Testen der Strategie im 15-Minuten-Zeitrahmen:

Die folgenden Diagramme zeigen die Ergebnisse:

Auf der Grundlage der vorangegangenen Ergebnisse haben wir die folgenden Zahlen aus diesem Test:

• Nettogewinn (NetProfit): 14791
• Balance DD Relative: 6.78%
• Profit Factor: 1.17
• Expected Payoff: 24.53
• Recovery Factor: 1.91
• Sharpe Ratio: 2.23

Testen der Strategie auf dem 1-Stunden-Zeitrahmen:

Die folgenden Diagramme zeigen die Ergebnisse:

Auf der Grundlage der vorangegangenen Ergebnisse haben wir die folgenden Zahlen aus diesem Test:

• Nettogewinn (NetProfit): 6242.20
• Balance DD Relative: 1.80%
• Profit Factor: 1.39
• Expected Payoff: 53.81
• Recovery Factor: 2.43
• Sharpe Ratio: 3.23

Die Strategie der Aroon-Level:

In diesem Teil werden wir die Aroon-Levels-Strategie testen, die auf dem gleichen Konzept basiert. Wir werden die gleiche Strategie auf zwei Zeitrahmen testen, 15 Minuten und 1 Stunde, um die gleichen Zahlen für beide Zeitrahmen zu vergleichen.

Testen der Strategie im 15-Minuten-Zeitrahmen:

Die folgenden Diagramme zeigen die Ergebnisse der Tests:

Auf der Grundlage der vorangegangenen Ergebnisse haben wir die folgenden Zahlen aus diesem Test:

• Nettogewinn (NetProfit): 42417.30
• Balance DD Relative: 12.91%
• Profit Factor: 1.21
• Expected Payoff: 29.62
• Recovery Factor: 2.27
• Sharpe Ratio: 1.88

Testen der Strategie auf dem 1-Stunden-Zeitrahmen:

Die folgenden Diagramme zeigen die Ergebnisse der Tests:

Auf der Grundlage der vorangegangenen Ergebnisse haben wir die folgenden Zahlen aus diesem Test:

• Nettogewinn (NetProfit): 16001.10
• Balance DD Relative: 5.11%
• Profit Factor: 1.30
• Expected Payoff: 41.89
• Recovery Factor: 2.68
• Sharpe Ratio: 2.61

In der folgenden Abbildung sind alle Ergebnisse zum besseren Vergleich an einem Ort zusammengefasst:

Auf der Grundlage der obigen Angaben können wir die besten Zahlen finden, die der getesteten Strategie und dem Zeitrahmen entsprechen, wie im Folgenden beschrieben:

• Nettogewinn (NetProfit):  Die beste höhere Zahl (42.417,30 USD) wird mit der Aroon-Level-Strategie angezeigt, wenn sie auf dem 15-Minuten-Zeitrahmen getestet wird.
• Balance DD Relative: Der beste untere Wert (1,80%) wird mit der Aroon Crossover-Strategie angezeigt, wenn sie auf dem 1-Stunden-Zeitrahmen getestet wird.
• Profit Factor: Der beste höhere Wert (1,39) wird mit der Aroon Crossover-Strategie angezeigt, wenn sie auf dem 1-Stunden-Zeitrahmen getestet wird.
• Expected Payoff: Der höhere Wert (53,81) wird bei der Aroon Crossover-Strategie angezeigt, wenn sie auf dem 1-Stunden-Zeitrahmen getestet wird.
• Recovery Factor: Der höhere Wert (2,68) wird bei der Aroon-Level-Strategie angezeigt, wenn sie auf dem 1-Stunden-Zeitrahmen getestet wird.
• Sharpe Ratio: Der höhere Wert (3,23) wird für die Aroon Crossover-Strategie angezeigt, wenn sie auf dem 1-Stunden-Zeitrahmen getestet wird.

Anhand der vorangegangenen Zahlen können wir eine geeignete Strategie wählen, die auf unseren Handelszielen basiert und mit welchen Zahlen wir diese Ziele erreichen können.

Schlussfolgerung

Der Aufbau und das Testen eines Handelssystems ist eine wichtige Aufgabe für jeden Händler, der es mit dem Handel ernst meint. In diesem Artikel haben wir versucht, einen Überblick über den Aroon-Indikator zu geben, der in jedem Handelssystem verwendet werden kann, entweder allein oder in Kombination mit anderen Tools. Dies kann für Ihren Handel hilfreich sein oder Ihnen Einblicke in den Aufbau eines guten Handelssystems geben.

Wir haben den Aroon-Indikator im Detail identifiziert, wie er auf der Grundlage seines Hauptkonzepts verwendet werden kann und wie wir ihn berechnen können. Wir haben zwei einfache Strategien ermittelt, die angewandt werden können:

• Aroon Crossover-Strategie: Diese Strategie ermöglicht es uns, automatisch eine Kaufposition zu platzieren, wenn die Aroon-Aufwärtslinie über der Aroon-Abwärtslinie liegt, oder eine Verkaufsposition, wenn die Aroon-Abwärtslinie über der Aroon-Aufwärtslinie liegt.
• Aroon Level-Strategie: Diese Strategie ermöglicht es uns, eine Kaufposition zu platzieren, wenn der Aroon Down unter der 10er-Marke des Indikators liegt, oder eine Verkaufsposition zu platzieren, wenn der Aroon Down über der 50er-Marke des Indikators liegt.

Wir haben diese Strategien kodiert, indem wir für jede einen EA erstellt haben, nachdem wir unseren nutzerdefinierten Aroon-Indikator mit MQL5 erstellt und ein einfaches Programm kodiert haben, das Aroon Up- und Aroon Down-Werte auf dem Chart generieren kann, indem wir den Indikator in das Chart einfügen. Wir haben sie getestet und wichtige Zahlen auf der Grundlage der Ergebnisse der Tests für jede Strategie für zwei Zeitrahmen von 15 Minuten und 1 Stunde ermittelt. Wir können sie je nach unseren Handelszielen und den Ergebnissen der einzelnen Strategien einsetzen.

Wir müssen uns auch darüber im Klaren sein, dass diese genannten Strategien möglicherweise mehr Optimierung und mehr Aufwand erfordern, um bessere Ergebnisse zu erzielen. Das Hauptziel dieses Artikels ist es, zu zeigen, was wir tun können, indem wir einige Ideen über verschiedene Handelssysteme austauschen, die unseren Geist für den Aufbau oder die Entwicklung besserer Handelssysteme öffnen können.

Ich hoffe, Sie fanden diesen Artikel nützlich in Ihrem Handel und Entwicklung Reise zu besseren und effektiveren Ergebnissen zu erhalten. Wenn Sie diesen Artikel interessant fanden und Sie mehr über den Aufbau von Handelssystemen auf der Grundlage verschiedener Strategien und verschiedene technische Indikatoren wissen wollen, können Sie über die Seite meiner Publikation meine früheren Artikel lesen. Dort gibt es viele Artikel über die beliebtesten technischen Indikatoren und ich hoffe, Sie können Ihnen helfen.