Klassische Strategien neu interpretiert (Teil 16): Doppelte Ausbrüche aus den Bollinger Bänder

MetaTrader 5 — Beispiele | 15 Januar 2026, 09:24

Die Finanzmärkte sind nicht nur statische, unbewegliche Maschinen, die in diskreten Zuständen existieren. Vielmehr sind die Finanzmärkte lebende, atmende und intelligente Systeme, die auf Informationen reagieren. Sie sind ständig in Bewegung und verharren nie auf einem festen Stand, doch die meisten Handelsstrategien behandeln sie so, als ob dies der Fall wäre.

Die meisten Handelsstrategien stufen den Markt in der Regel als trend- oder bandbreitenorientiert ein und schlagen dann je nach der ermittelten Marktlage entsprechende Schritte vor. Dieser Artikel soll dem Leser verdeutlichen, dass diese Sichtweise des Marktes zu einfach ist, um praktikabel zu sein. Wenn wir Strategien wollen, die mit den sich ständig verändernden Märkten Schritt halten können, mit Märkten, die zuweilen sogar gegnerisch agieren können, dann brauchen wir Instrumente, die die Finanzmärkte als das akzeptieren, was sie sind: ein sich ständig entwickelndes und nur teilweise beobachtbares System.

Hier kommen Handelsstrategien wie das System der doppelten Bollinger-Bänder ins Spiel. Es handelt sich um eine Erweiterung des klassischen Systems der Bollinger-Bänder, und es wird allgemein angenommen, dass es von institutionellen Händlern entwickelt wurde. Es kann problemlos an sich ändernde Marktbedingungen angepasst werden. Die Backtest-Ergebnisse, die wir in Kürze zeigen werden, werden unsere Ausführungen bestätigen. Die meisten Handelsstrategien mit den Bollinger-Bänder sind auf Lehrbuchregeln beschränkt und gehen davon aus, dass Sie unter günstigen Marktbedingungen arbeiten. Sie sagen Ihnen, dass Sie Ausbrüche oder Rücksetzer handeln sollen, aber sie erfassen nicht die chaotische Realität, wie sich die Märkte tatsächlich verhalten und ständig zwischen günstigen und ungünstigen Zuständen wechseln.

In unserer Methodik haben wir eine bekannte Variante der klassischen Strategie der Bollinger-Bänder implementiert, die den meisten Händlern in unserer Community bekannt ist. Diese Version der Strategie setzte Rentabilitätsmaßstäbe, die die doppelten Bollinger Bänder übertreffen sollten. Wie wir gleich sehen werden, haben wir beim Test des Ausbruchs der Standard-Bollinger-Bänder tatsächlich Geld verloren.

Beide Strategien wurden über denselben fünfjährigen historischen Zeitraum von Januar 2020 bis 2025 getestet. Wir haben unser Bestes getan, um sicherzustellen, dass beide Strategien auf identischen Parametern beruhen, wo immer dies möglich war. Die klassische Strategie verlor durchweg Geld, während das System mit den doppelten Bollinger Bändern bei festen Parametern wie der Periode der Bollinger Bänder und der verwendeten Losgröße deutlich besser abschnitt. Wir werden auf diese Ergebnisse noch näher eingehen. Doch zunächst möchte ich unsere wichtigsten Ergebnisse kurz zusammenfassen.

Die klassische Strategie führte über fünf Jahre zu einem Bruttoverlust von -169 USD, während das System mit dem doppelten Bollinger-Bänder unter den gleichen Bedingungen und unter Verwendung von festen Parametern, wo immer möglich, einen Bruttogewinn von 228 USD erzielte. Aus Gründen der Fairness wurden alle Handelsgeschäfte mit einer minimalen Losgröße eröffnet, und jede Strategie war auf ein offenes Handelsgeschäft zur gleichen Zeit beschränkt. Außerdem ergab die klassische Strategie eine negative Sharpe Ratio von -0,53, während die verbesserte Version eine positive Sharpe Ratio von 0,5 erzielte. Dies bedeutet eine deutliche Verbesserung der Rentabilität und Stabilität.

Was die Genauigkeit anbelangt, so hat die klassische Strategie über fünf Jahre 46 % gewinnbringende Abschlüsse erzielt – nicht gerade beeindruckend. Das System mit dem doppelten Bollinger-Bändern erzielte jedoch 56 % erfolgreiche Abschlüsse, was einer Verbesserung der Genauigkeit um 21 % entspricht. Noch auffälliger ist die asymmetrische Art und Weise, in der wir die Verteilung von Gewinnen und Verlusten verändert haben. Die Lösung, die wir dem Leser vorstellen, steigerte die Bruttogewinne des Backtests um 70 %, die Bruttoverluste jedoch nur um 17 %. Dieser asymmetrische Effekt – die Gewinne wachsen schneller als die Verluste – zeigt, wie angemessen das System der doppelten Bollinger-Bänder die Handelsverteilung in eine wünschenswertere Form umgestaltet.

Betrachtet man schließlich die Veränderungen des Gewinnfaktors, so ergibt sich für die ursprüngliche Strategie ein Faktor von 0,82, was bedeutet, dass sie im Laufe der Zeit Kapital verloren hat. Das System der doppelten Bollinger-Bänder ergab einen Faktor von 1,2, ein wichtiger Indikator für Kapitalwachstum, was einer Verbesserung des Gewinnfaktors um 50 % entspricht.

Zusammengenommen deuten diese Ergebnisse darauf hin, dass das System der doppelten Bollinger-Bänder nicht nur eine Verbesserung des ursprünglichen Systems ist, sondern einen Paradigmenwechsel darstellt. Sie stellt eine neue Familie von Strategien dar, die mit dem klassischen Ansatz verwandt sind, aber dessen Ergebnisse grundlegend verändern. Das System verwandelte eine Verluststrategie in eine Gewinnstrategie, verbesserte die Rentabilität dramatisch und behielt dabei eine bemerkenswerte Risikokontrolle.

Am wichtigsten ist jedoch, dass diese Verbesserungen ohne unnötige Komplexität erreicht wurden. Das System der doppelten Bollinger-Bänder ist immer noch einfach zu erlernen, umzusetzen und zu interpretieren, bietet aber weitaus größere Vorteile. Das begeistert mich am meisten, denn wenn wir uns in Zukunft dafür entscheiden, die Komplexität zu erhöhen – durch maschinelle Lernmodelle zur Optimierung von Ein- und Ausstiegen oder sogar durch rückgekoppelte Regler zur Anpassung an vorherrschende Muster – können wir sicher sein, dass sich der Aufwand lohnt und die zugrunde liegende Strategie profitabel ist.

Auch ohne solche Zusätze bietet das System der doppelten Bollinger-Bänder bereits Einfachheit mit einem Vorteil – eine äußerst wünschenswerte Eigenschaft für jede Handelsanwendung. Beginnen wir.

Überblick über die klassische Handelsstrategie

Wir beginnen damit, dass wir den Indikator der klassischen Bollinger-Bänder auf unser Chart anwenden, wie wir es normalerweise tun würden. Für diese Diskussion haben wir das Währungspaar EURUSD ausgewählt und werden es im täglichen Zeitrahmen analysieren. Daher haben wir in Abbildung 1 unten die Bollinger-Bänder so eingestellt, dass sie einen Zeitraum von 20 Tageskerzen verwenden. Wir werden unsere oberen und unteren Bänder mit 2 Standardabweichungen vom mittleren Band markieren, da dies der klassische Aufbau ist.

Abbildung 1: Anwendung unseres Bollinger Bands Indikators auf das EURUSD-Paar mit klassischen Eingabeeinstellungen

Die klassische Version der Handelsstrategie ist sehr einfach. Sobald die Kurse über das oberste Band ausbrechen, werden wir verkaufen. Umgekehrt werden wir kaufen eingehen, wenn die Kurse unter das unterste Band fallen. Die Strategie der klassischen Bollinger-Bänder beruht auf der Annahme, dass sich die Märkte in Zyklen bewegen, die sich im Mittelwert umkehren. Daher wird erwartet, dass auf Ausbrüche über eines der beiden extremen Bandniveaus eine Kursbewegung folgt, die das Kursniveau wieder auf das mittlere Band zurückführt.

Abbildung 2: Visualisierung der Strategie der klassischen Version der Bollinger-Bänder

Wie bei jeder Handelsstrategie gibt es inhärente Beschränkungen in Verbindung mit den Handelsregeln, die wir für das klassische Setup definiert haben. Es ist allgemein bekannt, dass solche Handelsstrategien anfällig für falsche Ausbrüche sind. Einfach ausgedrückt: Die Marktbedingungen können lethargisch genug driften, um unsere Einstiegssignale auszulösen, bevor sie ihren Kurs heftig ändern und zu ihrer ursprünglichen Flugbahn zurückkehren. Solche Handelsbedingungen werden das Kapital eines jeden Anlegers kontinuierlich aufzehren.

Die nachstehende Abbildung 3 kann dem Leser helfen, sich die Schwächen der von uns hervorgehobenen Strategie vor Augen zu führen. In der Abbildung sehen wir 2 Verkaufsarrangements, die anhand der zuvor definierten Regeln korrekt identifiziert wurden. Wie wir jedoch sehen können, hat nur einer der Abschlüsse das erwartete Ergebnis gebracht. Beim ersten Handel, der durch den grünen Kasten begrenzt wird, kehrten die Kurse zur Mitte des Bandes zurück, nachdem sie kurzzeitig über das obere Band ausgebrochen waren. Anschließend schien er jedoch dasselbe Muster in dem von den Kerzen in der roten Box begrenzten Zeitraum zu wiederholen, aber dies war ein falscher Ausbruch. Die Kurse stiegen weiter an und fielen nicht, wie von der klassischen Strategie erwartet, in die Mitte des Bandes zurück.

Abbildung 3: Visualisierung der Grenzen der klassischen Strategie der Bollinger-Bänder

Erste Schritte in MQL5

Wie bei den meisten unserer Handelsanwendungen beginnen wir mit der Definition von Systemkonstanten. Diese Definitionen sind der Eckpfeiler unserer Tests, da sie so viele Parameter wie möglich in beiden Experimenten beibehalten. Wichtige Parameter, wie die Periode der Bollinger Bänder, die Verschiebungen, die Rückblicke der Indikatoren, die Zeitrahmen und die Standardabweichungen, die für die Bänder verwendet werden, müssen festgelegt bleiben, da sie das Verhalten der Strategie stark verändern.

//+------------------------------------------------------------------+
//|                                                DBB Benchmark.mq5 |
//|                                               Gamuchirai Ndawana |
//|                    https://www.mql5.com/en/users/gamuchiraindawa |
//+------------------------------------------------------------------+
#property copyright "Gamuchirai Ndawana"
#property link      "https://www.mql5.com/en/users/gamuchiraindawa"
#property version   "1.00"

//+------------------------------------------------------------------+
//| System definitions                                               |
//+------------------------------------------------------------------+
#define BB_PERIOD   20
#define BB_SHIFT    0
#define ATR_PERIOD  14
#define ATR_PADDING 2
#define BB_SD_1     2
#define BB_SD_2     1
#define TF_1        PERIOD_D1

Nach den Konstanten definieren wir globale Variablen. Die meisten globalen Variablen beziehen sich auf die technischen Indikatoren, auf die wir uns verlassen, und auf die Stop-Loss-Größe, die wir verwenden werden.

//+------------------------------------------------------------------+
//| Global variables                                                 |
//+------------------------------------------------------------------+
int    bb_handler,bb_handler_2,atr_handler;
double bb_reading_u[],bb_reading_m[],bb_reading_l[],bb_reading_u_2[],bb_reading_m_2[],bb_reading_l_2[],atr_reading[];
double padding,close;

Anschließend importieren wir die Bibliotheken, die für den Handel und die Erfassung von Handelsinformationen wie Geld- und Briefkursen benötigt werden. Bibliotheken spielen in fast jedem Anwendungsentwicklungsprozess eine wichtige Rolle, da wir selten den gesamten Code von Grund auf neu schreiben.

//+------------------------------------------------------------------+
//| Library                                                          |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
#include <VolatilityDoctor\Trade\TradeInfo.mqh>

CTrade    Trade;
TradeInfo *TradeInfoHandler;

Wenn die Anwendung zum ersten Mal geladen wird, initialisieren wir die globalen Variablen: leere Datenstrukturen und eine neue Instanz unserer nutzerdefinierten Handelsinformationsklasse.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Setup our technical indicators
   bb_handler       = iBands(Symbol(),TF_1,BB_PERIOD,BB_SHIFT,BB_SD_1,PRICE_CLOSE);
   bb_handler_2     = iBands(Symbol(),TF_1,BB_PERIOD,BB_SHIFT,BB_SD_2,PRICE_CLOSE);
   atr_handler      = iATR(Symbol(),TF_1,ATR_PERIOD);
   TradeInfoHandler = new TradeInfo(Symbol(),TF_1);
//---
   return(INIT_SUCCEEDED);
  }

Wenn die Anwendung nicht mehr verwendet werden soll, müssen wir daran denken, die Speicherressourcen freizugeben, die zuvor den von uns definierten Handlern zugewiesen wurden.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Release the indicators we are no longer using
   IndicatorRelease(bb_handler);
   IndicatorRelease(bb_handler_2);
   IndicatorRelease(atr_handler);
  }

Im klassischen Setup der Strategie ist die Einstiegslogik einfach und leicht zu interpretieren. Wenn das Hoch der Bollinger Bänder vom Schlusskurs durchbrochen wird, verkaufen wir; wenn das Tief des Bollinger Bandes vom Schlusskurs durchbrochen wird und wir keine offenen Positionen haben, kaufen wir.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Keep track of time
   static datetime timestamp;
   datetime current_time = iTime(Symbol(),TF_1,0);

   if(timestamp != current_time)
     {
      //--- Update indicator readings
      CopyBuffer(bb_handler,0,0,1,bb_reading_m);
      CopyBuffer(bb_handler,1,0,1,bb_reading_u);
      CopyBuffer(bb_handler,2,0,1,bb_reading_l);
      CopyBuffer(bb_handler_2,0,0,1,bb_reading_m_2);
      CopyBuffer(bb_handler_2,1,0,1,bb_reading_u_2);
      CopyBuffer(bb_handler_2,2,0,1,bb_reading_l_2);
      CopyBuffer(atr_handler,0,0,1,atr_reading);

      //--- Get updated market readings
      close = iClose(Symbol(),TF_1,0);
      padding = atr_reading[0] * 2;

      //--- If we have no open positions
      if(PositionsTotal() == 0)
        {
         if(close > bb_reading_u[0])
            Trade.Sell(TradeInfoHandler.MinVolume(),Symbol(),TradeInfoHandler.GetBid(),TradeInfoHandler.GetAsk()+padding,TradeInfoHandler.GetAsk()-padding);

         else
            if(close < bb_reading_l[0])
               Trade.Buy(TradeInfoHandler.MinVolume(),Symbol(),TradeInfoHandler.GetAsk(),TradeInfoHandler.GetBid()-padding,TradeInfoHandler.GetBid()+padding);
        }
     }
  }
//+------------------------------------------------------------------+

Nachdem die Anwendung ausgeführt wurde, werden die Systemkonstanten, die wir zu Beginn erstellt haben, wieder zurückgesetzt – auch dies eine bewährte Vorgehensweise für MQL5-Code.

//+------------------------------------------------------------------+
//| Undefine system definitions                                      |
//+------------------------------------------------------------------+
#undef BB_PERIOD
#undef BB_SD_1
#undef BB_SD_2
#undef BB_SHIFT
#undef ATR_PADDING
#undef ATR_PERIOD
#undef TF_1
//+------------------------------------------------------------------+

Wenn alle Teile zusammengefügt sind, ist dies der Steuerungsaufbau für unsere klassische Anwendung.

//+------------------------------------------------------------------+
//|                                                DBB Benchmark.mq5 |
//|                                               Gamuchirai Ndawana |
//|                    https://www.mql5.com/en/users/gamuchiraindawa |
//+------------------------------------------------------------------+
#property copyright "Gamuchirai Ndawana"
#property link      "https://www.mql5.com/en/users/gamuchiraindawa"
#property version   "1.00"

//+------------------------------------------------------------------+
//| System definitions                                               |
//+------------------------------------------------------------------+
#define BB_PERIOD   20
#define BB_SHIFT    0
#define ATR_PERIOD  14
#define ATR_PADDING 2
#define BB_SD_1     2
#define BB_SD_2     1
#define TF_1        PERIOD_D1

//+------------------------------------------------------------------+
//| Global variables                                                 |
//+------------------------------------------------------------------+
int    bb_handler,bb_handler_2,atr_handler;
double bb_reading_u[],bb_reading_m[],bb_reading_l[],bb_reading_u_2[],bb_reading_m_2[],bb_reading_l_2[],atr_reading[];
double padding,close;

//+------------------------------------------------------------------+
//| Library                                                          |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
#include <VolatilityDoctor\Trade\TradeInfo.mqh>

CTrade    Trade;
TradeInfo *TradeInfoHandler;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Setup our technical indicators
   bb_handler       = iBands(Symbol(),TF_1,BB_PERIOD,BB_SHIFT,BB_SD_1,PRICE_CLOSE);
   bb_handler_2     = iBands(Symbol(),TF_1,BB_PERIOD,BB_SHIFT,BB_SD_2,PRICE_CLOSE);
   atr_handler      = iATR(Symbol(),TF_1,ATR_PERIOD);
   TradeInfoHandler = new TradeInfo(Symbol(),TF_1);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Release the indicators we are no longer using
   IndicatorRelease(bb_handler);
   IndicatorRelease(bb_handler_2);
   IndicatorRelease(atr_handler);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Keep track of time
   static datetime timestamp;
   datetime current_time = iTime(Symbol(),TF_1,0);

   if(timestamp != current_time)
     {
      //--- Update indicator readings
      CopyBuffer(bb_handler,0,0,1,bb_reading_m);
      CopyBuffer(bb_handler,1,0,1,bb_reading_u);
      CopyBuffer(bb_handler,2,0,1,bb_reading_l);
      CopyBuffer(bb_handler_2,0,0,1,bb_reading_m_2);
      CopyBuffer(bb_handler_2,1,0,1,bb_reading_u_2);
      CopyBuffer(bb_handler_2,2,0,1,bb_reading_l_2);
      CopyBuffer(atr_handler,0,0,1,atr_reading);

      //--- Get updated market readings
      close = iClose(Symbol(),TF_1,0);
      padding = atr_reading[0] * 2;

      //--- If we have no open positions
      if(PositionsTotal() == 0)
        {
               if(close > bb_reading_u[0])
                  Trade.Sell(TradeInfoHandler.MinVolume(),Symbol(),TradeInfoHandler.GetBid(),TradeInfoHandler.GetAsk()+padding,TradeInfoHandler.GetAsk()-padding);

               else
                  if(close < bb_reading_l[0])
                     Trade.Buy(TradeInfoHandler.MinVolume(),Symbol(),TradeInfoHandler.GetAsk(),TradeInfoHandler.GetBid()-padding,TradeInfoHandler.GetBid()+padding);
        }
     }
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Undefine system definitions                                      |
//+------------------------------------------------------------------+
#undef BB_PERIOD
#undef BB_SD_1
#undef BB_SD_2
#undef BB_SHIFT
#undef ATR_PADDING
#undef ATR_PERIOD
#undef TF_1
//+------------------------------------------------------------------+

Analysieren wir nun die Leistung der Anwendung während des fünfjährigen Backtests. Der Gesamtnettogewinn beträgt -169, was nicht beeindruckend ist. Die Sharpe Ratio liegt bei -0,53, und der Prozentsatz der profitablen Geschäfte liegt mit 46 % unter 50 %. Kurz gesagt, diese Anwendung schneidet schlechter ab als der Zufall und ist durchweg unrentabel.

Abbildung 4: Visualisierung der detaillierten Statistiken, die von der klassischen Handelsstrategie erzeugt werden

Die Kapitalkurve für die klassische Strategie zeigt einen anhaltenden Abwärtstrend, der mit der Zeit immer stärker wird.

Abbildung 5: Die klassische Version der Handelsstrategie führt zu einem negativen Trend im Zeitverlauf

Überblick über die überarbeitete Handelsstrategie

Die Verbesserung ist ganz einfach: Anstelle eines einzigen Bollinger-Bands verwenden wir zwei Bänder. Das innere Band verwendet eine kleinere Standardabweichung, das äußere Band eine größere. Wenn das innere Band durchbrochen wird, interpretieren wir dies als Trendfolgesignal; wenn das äußere Band (mit zwei Standardabweichungen) durchbrochen wird, interpretieren wir dies als Signal für eine Rückkehr zum Mittelwert. Konkret heißt das: Wird das innere Band am Hoch durchbrochen, kaufen wir (Trendfolge); wird das äußere Band am Hoch durchbrochen, verkaufen wir (Rückkehr zum Mittelwert). Die Umkehrung dieser Regeln gilt für die unteren Bänder.

Um diese Strategie zu verwirklichen, müssen wir nur die Eingaberegeln ändern; der größte Teil des Codes bleibt unverändert.

Abbildung 6: Wir fügen einen zweiten Filter hinzu, ein engeres Niveau der Standardabweichung des Bollinger Bandes, aber wir behalten die Periode bei

Wir können die überarbeitete Version der Strategie mit unserem MetaTrader 5 Terminal visualisieren. Bitte beachten Sie, dass Sie den ersten Indikator, den wir angewendet haben, nicht löschen oder zu einem neuen Chart wechseln müssen. Wir verwenden einfach eine zweite Instanz des Bollinger-Bänder-Indikators auf das gleiche Chart an, das wir ausgewählt haben.

Abbildung 7: Visualisierung der neu gestalteten Version der klassischen Strategie der Bollinger Bänder.

Die Umsetzung unserer Verbesserungen

Wir sind nun bereit, die Verbesserungen der Strategie der doppelten Bollinger-Bänder umzusetzen.

//--- If we have no open positions
if(PositionsTotal() == 0)
      {
         //--- Is the close price above the highest band? Buy
         if(close > bb_reading_u[0])
            Trade.Buy(TradeInfoHandler.MinVolume(),Symbol(),TradeInfoHandler.GetAsk(),TradeInfoHandler.GetBid()-padding,TradeInfoHandler.GetBid()+padding);

         //--- Is the close price below the lowest band? Sell
         else
            if(close < bb_reading_l[0])
               Trade.Sell(TradeInfoHandler.MinVolume(),Symbol(),TradeInfoHandler.GetBid(),TradeInfoHandler.GetAsk()+padding,TradeInfoHandler.GetAsk()-padding);

            //--- Is the close price above the mid-high band? Sell
            else
               if((close < bb_reading_u[0]) && (close > bb_reading_l[0]) && (close > bb_reading_u_2[0]))
                  Trade.Sell(TradeInfoHandler.MinVolume(),Symbol(),TradeInfoHandler.GetBid(),TradeInfoHandler.GetAsk()+padding,TradeInfoHandler.GetAsk()-padding);

               //--- Is the close price below the mid-low band? Buy
               else
                  if((close < bb_reading_u[0]) && (close > bb_reading_l[0]) && (close < bb_reading_l_2[0]))
                     Trade.Buy(TradeInfoHandler.MinVolume(),Symbol(),TradeInfoHandler.GetAsk(),TradeInfoHandler.GetBid()-padding,TradeInfoHandler.GetBid()+padding);
      }

Wir führen den Backtest über dasselbe Fünfjahresfenster durch, das sich von Januar 2020 bis März 2025 erstreckt.

Abbildung 8: Testen der verbesserten Version der Handelsstrategie mit den doppelten Bollinger-Bänder

Wie immer verwenden wir zufällige Verzögerungseinstellungen bei jeder Übernahme einer Position auf realen Ticks, um die Latenz und Unvorhersehbarkeit des Marktes besser zu emulieren.

Abbildung 9: Wählen Sie zufällige Verzögerungseinstellungen für eine zuverlässige Emulation der realen Marktbedingungen

Betrachtet man die detaillierten Statistiken für die verbesserte Strategie, so zeigt sich eine deutliche Veränderung in allen Bereichen. Der Gesamtnettogewinn wird positiv und verdoppelt sich in absoluten Zahlen im Vergleich zum klassischen System nahezu. Die erwartete Auszahlung steigt, der Gewinnfaktor verbessert sich, und der Prozentsatz der profitablen Geschäfte steigt auf attraktive 56 %. Oft lässt sich durch die Verbesserung einer Strategie die Anzahl der Geschäfte verringern und gleichzeitig die Rentabilität erhöhen. In diesem Fall sind jedoch sowohl die Gesamtzahl der Handelsgeschäfte als auch der Nettogewinn gestiegen. Das deutet darauf hin, dass die verbesserte Version zusätzliche Signale aufdeckt, für die das ursprüngliche System blind war.

Abbildung 10: Die überarbeitete Handelsstrategie hat die Leistungsstatistiken unserer Handelsanwendung erheblich verbessert

Schließlich hat sich die Kapitalkurve für die verbesserte Strategie vollständig verändert: Der frühere negative Trend ist jetzt positiv, und die neue Kapitalkurve erreicht höhere Spitzenwerte, die die alte Kurve niemals hätte erreichen können, egal wie lange sie lief.

Abbildung 11: Die Kapitalkurve, die sich aus der überarbeiteten Handelsstrategie ergibt, ist schließlich profitabel

Schlussfolgerung

Nach der Lektüre dieses Artikels wird der Leser erkennen, dass klassische Handelsstrategien, von denen wir glauben, sie zu verstehen, in Wirklichkeit ein Potenzial bergen, das wir noch nicht erkannt haben.

Die MQL5-API ermöglicht es uns, diese Strategien neu zu konzipieren. Mit gut definierten Methoden und anderen Hilfsprogrammen kann es eine Vielzahl von Handelsanwendungen erfassen, auch wenn die Größe der API festgelegt ist. Ja, die MQL5-API wächst jede Woche mit neuen Updates, die ständig zum MQL5-Framework hinzugefügt werden.

Aber selbst mit den wichtigsten Hilfsmitteln können wir immer wieder neue Anwendungen entwickeln, die die blinden Flecken der klassischen Strategien überbrücken. Die MQL5-API gibt uns Methoden an die Hand, die ein breites und dynamisches Maß an Nützlichkeit erreichen – genau das, was wir brauchen, um Anwendungen zu entwickeln, die sich der Veränderungen von Marktzuständen stärker bewusst sind, im Gegensatz zu ihren klassischen Vorgängern, die Märkte nur in statischen, binären Begriffen betrachteten.

Dateiname	Beschreibung der Datei
DBB.mq5	Die überarbeitete Handelsstrategie der doppelten Bollinger-Bänder, die wir zur Verbesserung unserer Ergebnisse eingeführt haben.
DBB_Benchmark.mq5	Die klassische Umsetzung der Bollinger-Bänder-Strategie.

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

Beigefügte Dateien |

ZIP herunterladen

DBB.mq5 (5.29 KB)

DBB_Benchmark.mq5 (4.47 KB)

Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.

Dieser Artikel wurde von einem Nutzer der Website verfasst und gibt dessen persönliche Meinung wieder. MetaQuotes Ltd übernimmt keine Verantwortung für die Richtigkeit der dargestellten Informationen oder für Folgen, die sich aus der Anwendung der beschriebenen Lösungen, Strategien oder Empfehlungen ergeben.

Andere Artikel von diesem Autor

Zur Diskussion im Händlerforum

Einführung in MQL5 (Teil 22): Aufbau eines Expert Advisors für das harmonische Muster 5-0

Dieser Artikel erklärt, wie man das harmonische Muster 5-0 in MQL5 erkennt und handelt, es mit Hilfe von Fibonacci-Levels validiert und auf dem Chart anzeigt.

Vom Neuling zum Experten: Backend Operations Monitor mit MQL5

Die Verwendung einer vorgefertigten Lösung im Handel, ohne sich mit der internen Funktionsweise des Systems zu befassen, mag zwar beruhigend klingen, doch ist dies für Entwickler nicht immer der Fall. Irgendwann tritt ein Upgrade, eine Leistungsstörung oder ein unerwarteter Fehler auf, und es ist wichtig, genau zu wissen, woher das Problem kommt, um es schnell zu diagnostizieren und zu beheben. Die heutige Diskussion konzentriert sich auf die Aufdeckung dessen, was normalerweise hinter den Kulissen eines Expert Advisors passiert, und auf die Entwicklung einer nutzerdefinierten Klasse für die Anzeige und Protokollierung von Backend-Prozessen mit MQL5. Dies gibt sowohl Entwicklern als auch Händlern die Möglichkeit, Fehler schnell zu lokalisieren, das Verhalten zu überwachen und auf spezifische Diagnoseinformationen für jeden EA zuzugreifen.

Eine alternative Log-datei mit der Verwendung der HTML und CSS

In diesem Artikel werden wir eine sehr einfache, aber leistungsfähige Bibliothek zur Erstellung der HTML-Dateien schreiben, dabei lernen wir auch, wie man eine ihre Darstellung einstellen kann (nach seinem Geschmack) und sehen wir, wie man es leicht in seinem Expert Advisor oder Skript hinzufügen oder verwenden kann.

MQL5-Assistenten-Techniken, die Sie kennen sollten (Teil 85): Verwendung von Mustern des Stochastik-Oszillators und der FrAMA mit Beta-VAE-Inferenzlernen

Dieser Beitrag schließt an Teil 84 an, in dem wir die Kombination von Stochastik und Fractal Adaptive Moving Average vorgestellt haben. Wir verlagern nun den Schwerpunkt auf das Inferenzlernen, um zu sehen, ob die im letzten Artikel unterlegenen Muster eine Trendwende erfahren könnten. Der Stochastik und der FrAMA sind eine sich ergänzende Paarung von Momentum und Trend. Für unser Inferenzlernen greifen wir auf den Beta-Algorithmus eines Variational Auto Encoders zurück. Außerdem implementieren wir, wie immer, eine nutzerdefinierte Signalklasse, die für die Integration mit dem MQL5-Assistenten entwickelt wurde.