English Русский 中文 Español 日本語 Português 한국어 Français Italiano Türkçe
preview
Lernen Sie, wie man ein Handelssystem mit dem Accelerator Oscillator entwickelt

Lernen Sie, wie man ein Handelssystem mit dem Accelerator Oscillator entwickelt

MetaTrader 5Handel | 9 Dezember 2022, 09:27
271 0
Mohamed Abdelmaaboud
Mohamed Abdelmaaboud

Einführung

Hier ist ein neuer Artikel aus unserer Serie darüber, wie man ein Handelssystem auf der Grundlage der beliebtesten technischen Indikatoren entwickelt. Wir werden in diesem Artikel ein neues technisches Werkzeug kennenlernen, das zu unseren Gunsten im Handel eingesetzt werden kann. Wir werden den Accelerator Oscillator Indikator (AC) im Detail kennenlernen, indem wir erfahren, was er ist, was er misst, wie er berechnet werden kann, wie man ihn liest und wie man ihn auch durch einfache Handelsstrategien nutzen kann und wie man dann ein darauf basierendes Handelssystem erstellen kann.

Die folgenden Themen werden uns dabei helfen, mehr über diesen Indikator zu erfahren:

  1. Definition des Beschleunigungsoszillators
  2. Accelerator Oscillator Strategie
  3. Accelerator Oscillator Strategieplan
  4. Accelerator Oscillator Handelssystem
  5. Schlussfolgerung

Wir werden die MQL5 (MetaQuotes Language 5) verwenden, um unsere Codes zu schreiben, die in das MetaTrader 5-Terminal eingebaut sind, das zur Ausführung unseres Handelssystems verwendet wird. Wenn Sie lernen wollen, wie man MetaTrader 5 herunterlädt und MQL5 verwendet, können Sie das Thema „Schreiben von MQL5-Code im MetaEditor“ aus einem früheren Artikel lesen, um mehr darüber zu erfahren. Alle hier erwähnten Strategien sind nur für Ausbildungszwecke gedacht und Sie müssen sie testen, bevor Sie sie in Ihrem realen Konto verwenden, um sicherzustellen, dass sie profitabel und für Sie geeignet sind. Ich rate Ihnen, zu versuchen, das Gelernte anzuwenden, wenn Sie Ihre Handels- und Codierungsfähigkeiten verbessern wollen, da dieser Schritt ein wichtiger Schritt ist, da er hilfreich sein wird, um den vollen Nutzen aus diesem Artikel zu ziehen.

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 Beschleunigungsoszillators

Der Accelerator Oscillator (AC) ist ein Momentum-Indikator, der von Bill Williams entwickelt wurde. Er misst, ob sich der Schwung verändert. Wenn das Momentum eines Aufwärtstrends abnimmt, kann dies bedeuten, dass weniger Interesse besteht, das Instrument zu kaufen, und in diesem Fall können wir eine andere Bewegung in die entgegengesetzte Richtung der Verkäufe sehen, und umgekehrt, wenn das Momentum eines Abwärtstrends abnimmt, kann dies bedeuten, dass weniger Interesse besteht, das Instrument zu verkaufen, und wir können eine Kaufkraft sehen. Er ist auch ein Frühindikator, da er sich vor dem Preis bewegen kann.

Das Hauptziel dieses Indikators besteht also darin, die Beschleunigung und Verlangsamung der Marktkraft in beide Richtungen zu messen, um Erkenntnisse darüber zu gewinnen, wie lange die aktuelle Preisbewegung anhalten wird, und um auf jede Änderung vorbereitet zu sein.

In den folgenden Schritten erfahren Sie, wie Sie diesen Indikator manuell berechnen können:

AC = AO - SMA (AO, 5)

Wobei:

Accelerator Oszillator.

AO = Awesome Oscillator, übrigens können Sie meinen früheren Artikel über den Awesome Oscillator lesen, um mehr über ihn zu erfahren.

SMA - einfacher gleitender Durchschnitt;

5 = die Periodenlänge des SMA.

Zur Berechnung der AO gehen wir wie folgt vor:

MEDIAN PRICE = (HIGH + LOW) / 2 

AO = SMA (MEDIAN PRICE, 5) - SMA (MEDIAN PRICE, 34)

Glücklicherweise müssen wir diesen Indikator nicht manuell berechnen, da er in der Handelsplattform MetaTrader 5 vorhanden ist und wir ihn nur aus den verfügbaren Indikatoren auswählen müssen. Beim Öffnen des Handelsterminals drücken wir auf Insert --> Indicators --> Bill Williams --> Accelerator Oscillator

 AC starten

Dann finden wir das Fenster der Indikatorparameter, in dem wir unsere Einstellungen wie folgt vornehmen können:

 AC Parameter

1 - die Farbe für Aufwärtswerte.

2 - die Dicke des Histogramms.

3 - die Farbe der Abwärtswerte.

Nachdem wir die vorherigen Parameter nach unseren Wünschen festgelegt und auf "OK" gedrückt haben, wird der Indikator wie folgt in das Chart gestartet:

 AC gestartet

Wie wir im vorherigen Chart sehen können, haben wir den Indikator im unteren Teil des Charts eingefügt und wir haben die AC-Werte oszillieren um Null auf der Grundlage der Beschleunigung des Momentums.

Die Nulllinie steht für ein Gleichgewicht zwischen den beiden Marktparteien Bullen und Bären besteht. Ist der AC über der Nulllinie, bedeutet dies eine Fortsetzung der Aufwärtsbewegung und umgekehrt, ist der AC unter ihr, bedeutet dies eine Fortsetzung der Abwärtsbewegung.


Accelerator Oscillator Strategie

In diesem Thema werden wir einfache Handelsstrategien kennenlernen, die auf dem Grundkonzept des AC-Indikators basieren. Sie müssen diese Strategien jedoch testen, bevor Sie sie auf Ihrem realen Konto anwenden, da das Hauptziel hier nur die Ausbildung ist. Sie müssen sich also vergewissern, dass es für Ihren Handel geeignet und rentabel ist.

    Strategie eins: AC kreuzt die Nulllinie:

      Auf der Grundlage dieser Strategie müssen wir den AC-Indikator verwenden, um zu wissen, wann ein Auf- oder Abwärtssignal vorliegt, indem wir zwei Werte vergleichen, um ihre Positionen zu bestimmen: den aktuellen AC-Wert und den Nullpunkt des AC-Indikators. Wenn der aktuelle AC-Wert über der Nulllinie liegt, ist dies ein Signal für eine Aufwärtsbewegung. Im anderen Fall, wenn der aktuelle AC-Wert unter der Nulllinie liegt, ist dies ein Signal für eine Abwärtsbewegung.

      Einfach:

      AC > Null --> Bullish

      AC < Null --> Bearish

        Strategie zwei: AC Stärke:

          Auf der Grundlage dieser Strategie müssen wir Signale mit der Stärke der AC-Bewegung erhalten, indem wir den aktuellen AC-Wert mit dem maximalen AC- und dem minimalen AC-Wert der letzten zehn AC-Werte vergleichen, um die Position jedes Wertes zu bestimmen und das geeignete Signal zu erhalten. Wenn der aktuelle AC-Wert größer als der maximale AC-Wert ist, handelt es sich um ein Signal der Stärke. Im anderen Fall, wenn der aktuelle AC-Wert niedriger ist als der minimale AC-Wert, ist dies ein Signal der Schwäche.

          Einfach:

          AC > Maximaler AC-Wert --> AC ist stark

          AC < Minimaler AC-Wert --> AC ist schwach

            Strategie drei: AC & MA Strategie

              Auf der Grundlage dieser Strategie müssen wir Kauf- oder Verkaufssignale erhalten, indem wir die fünf Werte überprüfen, und zwar den Schlusskurs, den exponentiellen gleitenden Durchschnitt über 50 Perioden, den aktuellen AC-Wert, den maximalen AC-Wert und den minimalen AC-Wert der letzten zehn AC-Werte, um deren Position zu bestimmen und das geeignete Signal zu erhalten. Wenn der aktuelle AC-Wert größer ist als der maximale AC-Wert und der Schlusskurs über dem 50-Perioden-EMA liegt, handelt es sich um ein Kaufsignal. Ist der aktuelle AC-Wert niedriger als der minimale AC-Wert und der Schlusskurs niedriger als der EMA der 50-Periode, handelt es sich um ein Verkaufssignal.

              Einfach:

              AC > Max AC-Wert und Close > 50- EMA --> Kaufen

              AC < Min AC-Wert und Close < 50- EMA --> Verkaufen 

              Accelerator Oscillator Strategieplan

              In diesem Thema werden wir einen Schritt-für-Schritt-Entwurf für jede erwähnte Strategie entwerfen, um uns zu helfen, ein Handelssystem reibungslos zu erstellen.

                Strategie eins: AC kreuzt die Nulllinie:

                  Nach dieser Strategie müssen wir ein Handelssystem entwickeln, das automatisch Auf- und Abwärtssignale als Kommentar auf dem Chart schreibt, indem es kontinuierlich den aktuellen AC-Wert und den Nullpunkt des AC-Indikators überprüft, um die Position zu bestimmen und das passende Signal zu liefern. Wenn der AC-Wert größer ist als die Nulllinie, muss das Handelssystem einen Kommentar auf dem Chart mit den folgenden Werten erzeugen:

                  • Bullish
                  • AC Value

                  Im anderen Fall, wenn der AC-Wert unter der Nulllinie liegt, muss das Handelssystem einen Kommentar auf dem Chart Folgendes ausgeben:

                  • Bearish
                  • AC Value

                  Nachfolgend finden Sie die Blaupause dieses Handelssystems:

                   AC Zero Crossover Blaupause

                    Strategie zwei: AC Stärke:

                      Nach dieser Strategie müssen wir ein Handelssystem erstellen, das auf das Stärke-Signal der AC-Bewegung reagiert. Dafür müssen drei Werte kontinuierlichen überprüft werden, der aktuelle AC-Wert, der maximale Wert, der minimale Wert der letzten zehn Werte des AC-Indikators. Wenn der aktuelle AC-Wert größer ist als der Maximalwert, muss das Handelssystem einen Kommentar auf dem Chart mit den folgenden Werten ausgeben:

                      • AC is strong
                      • AC value
                      • AC maximum value
                      • AC minimum value

                      Im anderen Fall, wenn der aktuelle AC-Wert niedriger als der Mindestwert ist, muss das Handelssystem einen Kommentar auf dem Chart mit den folgenden Werten zurückgeben:

                      • AC is weak
                      • AC value
                      • AC maximum value
                      • AC minimum value

                      Nachfolgend finden Sie die Blaupause dieses Handelssystems:

                      Vol - Stärke Blaupause

                        Strategie drei: AC & MA Strategie

                          Gemäß dieser Strategie müssen wir ein Handelssystem erstellen, das dazu verwendet werden kann, Kauf- und Verkaufssignale als Kommentar auf dem Chart zu generieren, basierend auf der kontinuierlichen Überprüfung der folgenden fünf Werte, dem aktuellen AC, dem maximalen AC, dem minimalen AC, dem Schlusskurs und dem Wert des gleitenden Durchschnitts, um die Position von ihnen zu bestimmen und das passende Signal zu generieren. Wenn der aktuelle AC-Wert größer ist als der maximale AC-Wert und der Schlusskurs größer ist als der gleitende Durchschnitt, muss das Handelssystem einen Kommentar auf dem Chart als Signal mit den folgenden Werten erzeugen:

                          • Buy
                          • Closing price
                          • AC value
                          • AC Max
                          • AC Min
                          • MA value

                          Im anderen Fall, wenn der aktuelle AC-Wert niedriger als der minimale AC-Wert ist und der Schlusskurs niedriger als der gleitende Durchschnitt ist, muss das Handelssystem einen Kommentar auf dem Chart mit den folgenden Werten ausgeben:

                          • Sell
                          • Closing price
                          • AC value
                          • AC Max
                          • AC Min
                          • MA value

                          Nachfolgend finden Sie die Blaupause dieses Handelssystems:

                           AC _ MA Strategie Blaupause

                          Accelerator Oscillator Handelssystem

                          In diesem interessanten Thema werden wir unser Handelssystem auf der Grundlage der erwähnten Strategien erstellen, aber wir werden eine Basis für sie schaffen, indem wir ein einfaches Handelssystem erstellen, das in der Lage sein wird, einen Kommentar auf dem Chart mit dem aktuellen AC-Wert zurückzugeben, und das Folgende zeigt die Schritte dazu:

                          Erstellen des Arrays acArray vom Typ „double“.

                          double acArray[];

                          Verwendung der Funktion "ArraySetAsSeries" für acArray, die den boolschen Wert true oder false zurückgibt. Die Parameter sind:

                          • array[]: Wir werden acArray verwenden.
                          • Flags: Wir werden „true“ für die Indexierungsrichtung des Arrays verwenden.
                          ArraySetAsSeries(acArray,true);

                          Verwendung des AC-Indikators mit Hilfe der Funktion "iAC" für das Handle des Accelerator Oscillator-Indikators. Die Parameter sind:

                          • symbol: Wir verwenden _Symbol, das aktuelle Symbol.
                          • period: Wir verwenden _Period, den aktuellen Zeitrahmen.
                          int acDef = iAC(_Symbol,_Period);

                          Wir holen uns die Daten aus dem Puffer des AC-Indikators mit der Funktion „CopyBuffer“. Die Parameter sind: 

                          • indicator_handle: Wir verwenden das Handel (acDef) des vordefinierten AC-Indikators.
                          • buffer_num: Dient zur Bestimmung der Nummer des Indikatorpuffers, wir verwenden 0.
                          • start_pos: Um die Startposition zu bestimmen, wird 0 verwendet.
                          • count: Bestimmt die zu kopierende Anzahl, wir benötigen 3.
                          • buffer[]: Das zu kopierende Ziel-Array, wir verwenden acArray.
                          CopyBuffer(acDef,0,0,3,acArray);

                          Definition des AC-Wertes nach Erstellung einer Double-Variablen für den acVal und Normalisierung mit Hilfe von „NormalizeDouble“. Die Parameter des „Normalizedouble“ sind:

                          • value: die zu normalisierende Zahl. Wir werden (acArray[0]) verwenden.
                          • digits: Anzahl der Nachkommastellen. Wir werden 7 verwenden.
                          double acVal = NormalizeDouble(acArray[0],7);

                          Wir schreiben mit der Funktion "Comment()" die aktuellen AC-Wert auf den Chart als Kommentar.

                          Comment("AC Value is ",acVal);

                          Nachfolgend der vollständige Code dieses Handelssystems:

                          //+------------------------------------------------------------------+
                          //|                                                    Simple AC.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()
                            {
                             double acArray[];
                             ArraySetAsSeries(acArray,true);
                             int acDef = iAC(_Symbol,_Period);
                             CopyBuffer(acDef,0,0,3,acArray);
                             double acVal = NormalizeDouble(acArray[0],7);
                             Comment("AC Value is ",acVal);
                            }
                          //+------------------------------------------------------------------+

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

                           Simple AC-Navigator

                          Um diese Datei auszuführen, ziehen Sie sie auf das gewünschte Chart und lassen Sie sie dort fallen. Es öffnet sich folgendes Fenster:

                           Einfacher AC Fenster

                           Einfacher AC gestartet

                          Wie wir auf dem Chart in der oberen rechten Ecke sehen können, läuft der Experte. Jetzt sind wir bereit, unser gewünschtes Signal zu empfangen, und es wird wie folgt aussehen:

                           Simple AC-Signal

                          Wie wir in der oberen linken Ecke sehen können, haben wir einen Kommentar zum aktuellen AC-Wert.

                            Strategie eins: AC kreuzt die Nulllinie:

                              Im Folgenden finden Sie den vollständigen Code zur Erstellung des Handelssystems dieser Strategie:

                              //+------------------------------------------------------------------+
                              //|                                            AC Zero Crossover.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()
                                {
                                 double acArray[];
                                 ArraySetAsSeries(acArray,true);
                                 int acDef = iAC(_Symbol,_Period);
                                 CopyBuffer(acDef,0,0,3,acArray);
                                 double acVal = NormalizeDouble(acArray[0],7);
                                 if(acVal > 0)
                                   {
                                    Comment("Bullish","\n"
                                            "AC Value is ",acVal);
                                   }
                                 if(acVal < 0)
                                   {
                                    Comment("Bearish","\n"
                                            "AC Value is ",acVal);
                                   }
                                }
                              //+------------------------------------------------------------------+

                              Unterschiede in diesem Code:

                              Bedingungen der Strategie.

                              Im Falle eines Aufwärtssignals:

                                 if(acVal > 0)
                                   {
                                    Comment("Bullish","\n"
                                            "AC Value is ",acVal);
                                   }

                              Im Falle eines Abwärtssignals:

                                 if(acVal < 0)
                                   {
                                    Comment("Bearish","\n"
                                            "AC Value is ",acVal);
                                   }

                              Nach dem Kompilieren und Ausführen dieses Codes, wie wir es zuvor gelernt haben, werden wir feststellen, dass der Experte auf dem Chart wie folgt gestartet wurde:

                               AC Zero Crossover gestartet

                              In der oberen rechten Ecke sehen wir, dass der Experte dieser Strategie auf dem Chart läuft. Wir sind jetzt bereit, unsere Signale zu empfangen.

                              Im Falle eines Aufwärtssignals:

                              AC Zero Crossover - Aufwärtssignal

                              In der oberen linken Ecke sehen wir den Kommentar als Signal dieser Strategie mit den folgenden Werten:

                              • Bullish
                              • AC Value

                              Im Falle eines Abwärtssignals:

                              AC Zero Crossover - Abwärtssignal

                              In der oberen linken Ecke sehen wir die folgenden Werte:

                              • Bearish
                              • AC Value
                                Strategie zwei: AC Stärke:

                                  Im Folgenden finden Sie den vollständigen Code zur Erstellung des Handelssystems dieser Strategie:

                                  //+------------------------------------------------------------------+
                                  //|                                                  AC Strength.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()
                                    {
                                     double acArray[];
                                     ArraySetAsSeries(acArray,true);
                                     int acDef = iAC(_Symbol,_Period);
                                     CopyBuffer(acDef,0,0,11,acArray);
                                     double acCurrVal = NormalizeDouble(acArray[0],7);
                                     int acMaxArray = ArrayMaximum(acArray,1,WHOLE_ARRAY);
                                     int acMinArray = ArrayMinimum(acArray,1,WHOLE_ARRAY);
                                     double acMaxVal = NormalizeDouble(acArray[acMaxArray],7);
                                     double acMinVal = NormalizeDouble(acArray[acMinArray],7);
                                     if(acCurrVal>acMaxVal)
                                       {
                                        Comment("AC is strong ","\n",
                                                "AC Value is ",acCurrVal,"\n",
                                                "AC Max is ",acMaxVal,"\n",
                                                "AC Min is ",acMinVal);
                                       }
                                     if(acCurrVal<acMinVal)
                                       {
                                        Comment("AC is weak ","\n",
                                                "AC Value is ",acCurrVal,"\n",
                                                "AC Max is ",acMaxVal,"\n",
                                                "AC Min is ",acMinVal);
                                       }
                                    }
                                  //+------------------------------------------------------------------+

                                  Unterschiede in diesem Code.

                                  Festlegung des aktuellen Wertes von AC:

                                  double acCurrVal = NormalizeDouble(acArray[0],7);

                                  Festlegung des Höchstwerts im gesamten Array von AC durch Verwendung der Funktion "ArrayMaximum", die den Höchstwert zurückgibt. Die Parameter:

                                  • array[]: Wir werden acArray verwenden.
                                  • start: Der Startpunkt, von dem aus geprüft wird. Wir werden 1 verwenden.
                                  • count: Gesamtzahl der zu prüfenden Elemente des Arrays. Wir werden (WHOLE_ARRAY) verwenden, um das gesamte Array zu überprüfen.
                                  int acMaxArray = ArrayMaximum(acArray,1,WHOLE_ARRAY);

                                  Festlegung des Mindestwerts im gesamten Array von AC durch Verwendung der Funktion "ArrayMinimum", die den Mindestwert zurückgibt. Die Parameter:

                                  • array[]: Wir werden acArray verwenden.
                                  • start: Der Startpunkt, von dem aus geprüft wird. Wir werden 1 verwenden.
                                  • count: Gesamtzahl der zu prüfenden Elemente des Arrays. Wir werden WHOLE_ARRAY verwenden, um das gesamte Array zu überprüfen.
                                  int acMinArray = ArrayMinimum(acArray,1,WHOLE_ARRAY);

                                  Normalisierung der Werte von Maximum und Minimum mit der Funktion "NormalizeDouble".

                                     double acMaxVal = NormalizeDouble(acArray[acMaxArray],7);
                                     double acMinVal = NormalizeDouble(acArray[acMinArray],7);

                                  Bedingungen der Strategie,

                                  Im Falle eines starken Signals:

                                     if(acCurrVal>acMaxVal)
                                       {
                                        Comment("AC is strong ","\n",
                                                "AC Value is ",acCurrVal,"\n",
                                                "AC Max is ",acMaxVal,"\n",
                                                "AC Min is ",acMinVal);
                                       }

                                  Im Falle eines schwachen Signals,

                                     if(acCurrVal<acMinVal)
                                       {
                                        Comment("AC is weak ","\n",
                                                "AC Value is ",acCurrVal,"\n",
                                                "AC Max is ",acMaxVal,"\n",
                                                "AC Min is ",acMinVal);
                                       }

                                  Nach dem Kompilieren und Ausführen dieses Codes auf dem gewünschten Chart sehen wir das Folgende:

                                  AC-Stärke gestartet

                                  Wie wir in der oberen rechten Ecke des Charts sehen, dass der Experte läuft, sind wir bereit, Signale dieser Strategie die gleichen wie die folgenden Beispiele aus der Prüfung zu erhalten.

                                  Im Falle eines starken Signals:

                                  Vol – Strength – starkes Signal

                                  Wie wir auf dem Chart in der oberen linken Ecke sehen können, haben wir ein Signal mit den folgenden Werten erhalten:

                                  • AC is strong
                                  • AC value
                                  • AC maximum value
                                  • AC minimum value

                                  Im Falle einer Schwäche:

                                  AC Stärke - schwaches Signal

                                  Wie wir sehen können, haben wir das Signal mit den folgenden Werten erhalten:

                                  • AC is weak
                                  • AC value
                                  • AC maximum value
                                  • AC minimum value
                                    Strategie drei: AC & MA Strategie

                                      Im Folgenden finden Sie den vollständigen Code zur Erstellung des Handelssystems dieser Strategie:

                                      //+------------------------------------------------------------------+
                                      //|                                             AC & MA Strategy.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()
                                        {
                                         MqlRates pArray[];
                                         double acArray[];
                                         double maArray[];
                                         int Data=CopyRates(_Symbol,_Period,0,1,pArray);
                                         ArraySetAsSeries(acArray,true);
                                         ArraySetAsSeries(maArray,true);
                                         int acDef = iAC(_Symbol,_Period);
                                         int maDef = iMA(_Symbol,_Period,50,0,MODE_EMA,PRICE_CLOSE);
                                         CopyBuffer(acDef,0,0,3,acArray);
                                         CopyBuffer(maDef,0,0,3,maArray);
                                         int acMaxArray = ArrayMaximum(acArray,1,WHOLE_ARRAY);
                                         int acMinArray = ArrayMinimum(acArray,1,WHOLE_ARRAY);
                                         double closingPrice = pArray[0].close;
                                         double acVal = NormalizeDouble(acArray[0],7);
                                         double acMaxVal = NormalizeDouble(acArray[acMaxArray],7);
                                         double acMinVal = NormalizeDouble(acArray[acMinArray],7);
                                         double maVal = NormalizeDouble(maArray[0],7);
                                         if(acVal > acMaxVal && closingPrice > maVal)
                                           {
                                            Comment("Buy","\n"
                                                    "Closing Price is ",closingPrice,"\n",
                                                    "Ac Value is ",acVal,"\n",
                                                    "AC Max is ",acMaxVal,"\n",
                                                    "AC Min is ",acMinVal,"\n",
                                                    "MA Value is ",maVal);
                                           }
                                         if(acVal < acMinVal && closingPrice < maVal)
                                           {
                                            Comment("Sell","\n"
                                                    "Closing Price is ",closingPrice,"\n",
                                                    "Ac Value is ",acVal,"\n",
                                                    "AC Max is ",acMaxVal,"\n",
                                                    "AC Min is ",acMinVal,"\n",
                                                    "MA Value is ",maVal);
                                           }
                                        }
                                      //+------------------------------------------------------------------+
                                      

                                      Unterschiede in diesem Code:

                                      Erstellen der Arrays pArray, acArray und maArray. acArray und maArray sind vom Typ „double“, während pArray vom Typ MqlRates ist, um Informationen über den Preis, das Volumen und den Spread abzurufen.

                                         MqlRates pArray[];
                                         double acArray[];
                                         double maArray[];

                                      Wir setzen das Flag AS_SERIES für die Arrays acArray und maArray, wie bereits erwähnt, und Definieren von Daten mit der Funktion "CopyRates", um historische Daten der MqlRates-Struktur und ihrer Parameter zu erhalten:

                                      • symbol_name: Wir verwenden _Symbol für das aktuelle Symbol.
                                      • timeframe: Wir verwenden _Period, den aktuellen Zeitrahmen.
                                      • start_pos: Um die Startposition zu bestimmen, wird 0 verwendet. 
                                      • count: Bestimmen der zu kopierenden Anzahl, wir benötigen 1.
                                      • rates_array[]: Um das zu Ziel-Array zu bestimmen, wir verwenden pArray.
                                         int Data=CopyRates(_Symbol,_Period,0,1,pArray);
                                         ArraySetAsSeries(acArray,true);
                                         ArraySetAsSeries(maArray,true);

                                      Definition von AC und MA:

                                      AC mit Hilfe der Funktion „iAC“, wie bereits erwähnt. Aber MA, werden wir die "iMA"-Funktion, ihre Parameter zu verwenden:

                                      • symbol: Wir werden (_Symbol) verwenden
                                      • period: Wir verwenden (_Period)
                                      • ma_period: Um die Periode des gleitenden Durchschnitts zu bestimmen, werden wir 50 verwenden 
                                      • ma_shift: Um die horizontale Verschiebung zu bestimmen, wird (0) verwendet 
                                      • ma_method: Um den Typ des gleitenden Durchschnitts zu bestimmen, werden wir den exponentiellen MA verwenden 
                                      • applied_price: Als Preistyp verwenden wir die Schlusskurse.
                                         int acDef = iAC(_Symbol,_Period);
                                         int maDef = iMA(_Symbol,_Period,50,0,MODE_EMA,PRICE_CLOSE);

                                      Abrufen von Daten aus dem Puffer der AC- und MA-Indikatoren mit Hilfe der Funktion „CopyBuffer“.

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

                                      Ermitteln der Max- und Min-Werte von acArray.

                                         int acMaxArray = ArrayMaximum(acArray,1,WHOLE_ARRAY);
                                         int acMinArray = ArrayMinimum(acArray,1,WHOLE_ARRAY);

                                      Festlegung der Werte von AC, AC Maximum, AC Minimum und Exponential Moving Average.

                                         double acVal = NormalizeDouble(acArray[0],7);
                                         double acMaxVal = NormalizeDouble(acArray[acMaxArray],7);
                                         double acMinVal = NormalizeDouble(acArray[acMinArray],7);
                                         double maVal = NormalizeDouble(maArray[0],7);

                                      Bedingungen der Strategie.

                                      Im Falle eines Kaufsignals:

                                         if(acVal > acMaxVal && closingPrice > maVal)
                                           {
                                            Comment("Buy","\n"
                                                    "Closing Price is ",closingPrice,"\n",
                                                    "Ac Value is ",acVal,"\n",
                                                    "AC Max is ",acMaxVal,"\n",
                                                    "AC Min is ",acMinVal,"\n",
                                                    "MA Value is ",maVal);
                                           }

                                      Im Falle eines Verkaufssignals:

                                         if(acVal < acMinVal && closingPrice < maVal)
                                           {
                                            Comment("Sell","\n"
                                                    "Closing Price is ",closingPrice,"\n",
                                                    "Ac Value is ",acVal,"\n",
                                                    "AC Max is ",acMaxVal,"\n",
                                                    "AC Min is ",acMinVal,"\n",
                                                    "MA Value is ",maVal);
                                           }

                                      Nachdem wir diesen Code kompiliert und ausgeführt haben, um unser Signal zu empfangen, wird er wie folgt angehängt:

                                      AC _ MA Strategie im Anhang

                                      Wie wir auf dem Chart in der oberen rechten Ecke sehen können, läuft der Experte. Jetzt können wir unsere Signale empfangen.

                                      Im Falle eines Kaufsignals:

                                      AC & MA Strategie - Kaufsignal

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

                                      • Buy
                                      • Closing price
                                      • AC value
                                      • AC Max
                                      • AC Min
                                      • MA value

                                      Im Falle eines Verkaufssignals:

                                      AC & MA Strategie - Verkaufssignal

                                      Wir sehen den Kommentar mit den folgenden Werten:

                                      • Sell
                                      • Closing price
                                      • AC value
                                      • AC Max
                                      • AC Min
                                      • MA value

                                      Schlussfolgerung

                                      Nach all dem, was wir in diesem Artikel gelernt haben, ist davon auszugehen, dass Sie den Accelerator Oscillator Indikator gut verstehen, da wir ihn in diesem Artikel behandelt haben und wir gelernt haben, was er ist, was er misst, wie wir ihn berechnen können, wie wir ihn lesen und durch einfache Handelsstrategien verwenden können, die die gleichen wie die folgenden waren:

                                      • AC Zero Crossover: Um Auf- und Abwärtssignale zu erhalten, die auf dem Crossover zwischen dem AC-Wert und der Nulllinie des AC-Indikators basieren.
                                      • AC-Stärke: Um ein Signal für die Stärke der AC-Bewegung zu erhalten, das auf dem Vergleich des aktuellen AC-Wertes mit dem Maximum und dem Minimum der letzten zehn AC-Werte beruht.
                                      • AC & MA Strategie: Um Kauf- und Verkaufssignale zu erhalten, die auf der Positionierung des Schlusskurses, des exponentiellen gleitenden Durchschnitts über 50 Perioden, des aktuellen AC-Werts, des AC-Höchstwerts und des AC-Mindestwerts basieren.

                                      Dann haben wir eine Schritt-für-Schritt-Blaupause für alle erwähnten Strategien entworfen, die uns dabei helfen soll, unser Handelssystem einfach, effektiv und reibungslos zu erstellen. Dann kamen wir zum interessantesten Teil des Artikels, als wir unsere Codes schrieben, um ein Handelssystem zu erstellen, das auf diesen erwähnten Strategien basiert und im MetaTrader 5 ausgeführt wird, um automatische Signale zu erzeugen, ohne dass die Bedingungen manuell gelesen oder überwacht werden müssen.

                                      Ich hoffe, dass Sie versuchen, das anzuwenden, was Sie gelernt haben. Es ist das Gleiche, das ich Ihnen zu Beginn dieses Artikels sagte. Dann können Sie alle Vorteile aus diesem Artikel ziehen, indem Sie mehr Einblicke über das Thema dieses Artikels oder ein verwandtes Thema erhalten. Ich muss hier ein weiteres Mal bekräftigen, dass Sie jede erwähnte Strategie testen müssen, bevor Sie sie auf Ihrem realen Konto verwenden, um sicherzustellen, dass sie profitabel oder für Ihren Handelsstil geeignet ist, denn es gibt nichts, was für alle geeignet ist. Darüber hinaus ist das Hauptziel hier ausschließlich die Bildung.

                                      Ich hoffe, dass Sie diesen Artikel als nützlich für Ihren Handel empfunden haben, um bessere Ergebnisse zu erzielen, und wenn Sie weitere ähnliche Artikel darüber lesen möchten, wie man ein Handelssystem auf der Grundlage der beliebtesten technischen Indikatoren wie RSI, MACD, MA, Stochastic, Bollinger Bands ...etc. entwickelt. Sie können meine früheren Artikel dieser Serie lesen, um mehr darüber zu erfahren.

                                      Übersetzt aus dem Englischen von MetaQuotes Ltd.
                                      Originalartikel: https://www.mql5.com/en/articles/11467

                                      Beigefügte Dateien |
                                      Simple_AC.mq5 (0.86 KB)
                                      AC_Strength.mq5 (1.46 KB)
                                      Neuronale Netze leicht gemacht (Teil 30): Genetische Algorithmen Neuronale Netze leicht gemacht (Teil 30): Genetische Algorithmen
                                      Heute möchte ich Ihnen eine etwas andere Lernmethode vorstellen. Wir können sagen, dass sie von Darwins Evolutionstheorie entlehnt ist. Sie ist wahrscheinlich weniger kontrollierbar als die zuvor besprochenen Methoden, aber sie ermöglicht die Ausbildung nicht-differenzierbarer Modelle.
                                      DoEasy. Steuerung (Teil 22): SplitContainer. Ändern der Eigenschaften des erstellten Objekts DoEasy. Steuerung (Teil 22): SplitContainer. Ändern der Eigenschaften des erstellten Objekts
                                      In diesem Artikel werde ich die Möglichkeit implementieren, die Eigenschaften und das Aussehen des neu erstellten SplitContainer-Steuerelements zu ändern.
                                      Einen Expert Advisor von Grund auf entwickeln (Teil 30): CHART TRADE als Indikator? Einen Expert Advisor von Grund auf entwickeln (Teil 30): CHART TRADE als Indikator?
                                      Heute werden wir wieder Chart Trade verwenden, aber dieses Mal wird es ein On-Chart-Indikator sein, der auf dem Chart laufen kann oder auch nicht.
                                      Neuronale Netze leicht gemacht (Teil 29): Der Algorithmus Advantage Actor Critic Neuronale Netze leicht gemacht (Teil 29): Der Algorithmus Advantage Actor Critic
                                      In den vorangegangenen Artikeln dieser Reihe haben wir zwei Algorithmen des verstärkten Lernens (Reinforcement Learning) kennengelernt. Jede von ihnen hat seine eigenen Vor- und Nachteile. Wie so oft in solchen Fällen kommt man dann auf die Idee, beide Methoden in einem Algorithmus zu kombinieren und das Beste aus beiden zu verwenden. Dies würde die Unzulänglichkeiten eines jeden von ihnen ausgleichen. Eine dieser Methoden wird in diesem Artikel erörtert.