Entwicklung einer Handelsstrategie: Die Methode der Butterfly-Oszillation

Einführung

Indikatoren sind mathematische Werkzeuge, die Marktdaten in grafischer Form darstellen. Sie helfen Händlern bei der Analyse von Markttrends, Volatilität und Momentum. Übliche Beispiele sind der Relative Strength Index (RSI), Average True Range (ATR), Moving Average (MA) und Relative Vigor Index (RVI). Jeder dieser Indikatoren erfüllt einen bestimmten Zweck bei der Identifizierung von Ein- und Ausstiegspunkten auf Handelschart.

In diesem Artikel stellen wir einen neuen technischen Indikator vor, den Butterfly-Oszillator, der auf einer berühmten mathematischen Kurve basiert, die 1989 von Temple H. Fay entdeckt wurde. Diese Kurve, die so genannte Butterfly-Kurve, verdankt ihren Namen der ausgeprägten flügelartigen Form eines Schmetterlings ihres Graphen. Ziel ist es, auf dieser mathematischen Grundlage den Butterfly-Oszillator zu konstruieren und eine entsprechende Handelsstrategie zu entwickeln.

Die Butterfly-Kurve: Eine mathematische Grundlage

Die Butterfly-Kurve wird durch ihre parametrischen Gleichungen definiert, die ihre charakteristische, flügelartige Form erzeugen:

Dabei erstreckt sich der Parameter t über das Intervall [0,12π].

Abbildung 1 veranschaulicht die Butterfly-Kurve.

Abbildung 1: Butterfly-Kurve

Bemerkenswert:

• Die Werte der x-Achse sind symmetrisch, während die Werte der y-Achse asymmetrisch sind.
• Die Gesamtstruktur ist nichtlinear und zyklisch, d. h. sie wiederholt ihr Muster periodisch.
• Die parametrische Gleichung nimmt eine einzelne Eingabe (t) und gibt entsprechende x- und y-Werte aus.

Code-Struktur zur Konstruktion der Butterfly-Kurve: 

An dieser Stelle zeigen wir, wie die Butterfly-Kurve mit Hilfe einer Skriptdatei in das Chart eingezeichnet wurde.

#include <Canvas\Canvas.mqh>

Der erste Schritt ist die Einbindung der Canvas-Bibliothek in MQL5 mit Hilfe der Zeile. Diese Bibliothek bietet alle notwendigen Klassen und Funktionen, die zum Zeichnen und Visualisieren der Butterfly-Kurve im Chart erforderlich sind. 

   // Create canvas for drawing
   int width = 800;   // Canvas width
   int height = 600;  // Canvas height
   string canvas_name = "ButterflyCurve";
   
   // Create canvas object
   CCanvas canvas;
   if(!canvas.CreateBitmapLabel(canvas_name, 200, 50, width, height, COLOR_FORMAT_XRGB_NOALPHA))
     {
      Print("Error creating canvas: ", GetLastError());
      return;
     }

Zunächst werden die Abmessungen der Leinwand festgelegt – mit einer Breite von 800 Pixeln und einer Höhe von 600 Pixeln – und der Name der Leinwand wird auf „ButterflyCurve“ festgelegt. Diese Parameter bestimmen die Größe und die Beschriftung der Zeichenfläche, die auf dem Chart erscheinen wird.

Als nächstes wird ein Canvas-Objekt (CCanvas canvas) deklariert, das als grafische Oberfläche für die Darstellung aller visuellen Elemente wie Linien, Formen und Text dient. Die Funktion CreateBitmapLabel() wird dann verwendet, um die Leinwand an einer bestimmten Position im Chart zu instanziieren – in diesem Fall 200 Pixel von links und 50 Pixel von oben. Die Funktion gibt auch das Farbformat (COLOR_FORMAT_XRGB_NOALPHA) an, das definiert, wie Farben und Transparenz verarbeitet werden.

Schließlich enthält der Code einen Mechanismus zur Fehlerbehandlung: Wenn die Erstellung der Leinwand fehlschlägt, gibt das Programm eine Fehlermeldung mit dem Fehlercode aus (GetLastError() ) und beendet die Ausführung. Dadurch wird sichergestellt, dass nachfolgende Zeichenvorgänge erst dann ausgeführt werden, wenn die Leinwand erfolgreich erstellt wurde und zur Verwendung bereit ist.

   // Set up drawing parameters
   int points = 1000;            // Number of points
   double t_start = 0;           // Start angle
   double t_end = 12 * M_PI;     // End angle
   double step = (t_end - t_start) / (points - 1);
   
   // Calculate curve points
   double x[], y[];
   ArrayResize(x, points);
   ArrayResize(y, points);
   
   for(int i = 0; i < points; i++)
     {
      double t = t_start + i * step;
      double expr = MathExp(MathCos(t)) - 2 * MathCos(4 * t) - MathPow(MathSin(t/12), 5);
      x[i] = MathSin(t) * expr;
      y[i] = MathCos(t) * expr;
     }

Dieser Teil des Codes definiert den mathematischen Aufbau und die Datenstruktur, die benötigt werden, um die Butterfly-Kurve zu erzeugen, bevor sie auf der Leinwand gezeichnet wird.

Zunächst werden die Zeichnungsparameter festgelegt:

• points gibt die Anzahl der Datenpunkte (1000) an, die zum Zeichnen der Kurve verwendet werden, um eine glatte und kontinuierliche Linie zu gewährleisten,
• t_start und t_end definieren den Bereich der Variablen t, die als Parameter für die Butterfly-Kurvengleichung dient – hier von 0 bis 12π,
• Schritt bestimmt die inkrementelle Änderung von t zwischen den einzelnen Punkten, um eine gleichmäßige Verteilung der Daten entlang der Kurve zu gewährleisten.

Als Nächstes werden zwei dynamische Arrays, x[] und y[], erstellt und in der Größe angepasst, um alle berechneten Koordinaten der Butterfly-Kurve aufzunehmen. Jedes Element in diesen Feldern entspricht einem Punkt auf der Kurve.

In der for-Schleife wird die Butterfly-Kurvengleichung für jeden Wert von t berechnet. Diese berechneten Werte stellen die geometrischen Koordinaten der Butterfly-Kurve dar, die später zum Skalieren und Plotten auf der Leinwand verwendet werden.

   // Find coordinate bounds for scaling
   double x_min = x[ArrayMinimum(x)];
   double x_max = x[ArrayMaximum(x)];
   double y_min = y[ArrayMinimum(y)];
   double y_max = y[ArrayMaximum(y)];
   
   // Scale points to canvas coordinates
   int x_px[], y_px[];
   ArrayResize(x_px, points);
   ArrayResize(y_px, points);
   
   double x_scale = (width - 40) / (x_max - x_min);
   double y_scale = (height - 40) / (y_max - y_min);
   double scale = MathMin(x_scale, y_scale); // Maintain aspect ratio
   
   for(int i = 0; i < points; i++)
     {
      x_px[i] = (int)((x[i] - x_min) * scale) + 20;
      y_px[i] = height - (int)((y[i] - y_min) * scale) - 20; // Flip Y-axis for canvas coordinates
     }

Dieser Abschnitt des Codes behandelt die Skalierung und Koordinatentransformation der berechneten Butterfly-Kurven-Datenpunkte, sodass sie genau in den Canvas-Bereich passen.

Zunächst bestimmt das Programm die Koordinatengrenzen der Kurve, indem es die minimalen und maximalen Werte der x- und y-Felder ermittelt. Diese Werte definieren den gesamten Bereich der Butterfly-Kurve in beiden Richtungen und sind für die korrekte Abbildung der Daten auf dem Bildschirm unerlässlich.

Als Nächstes werden zwei neue ganzzahlige Arrays – x_px und y_px – erstellt und in ihrer Größe an die Anzahl der Datenpunkte angepasst. In diesen Arrays werden die pixelbasierten Koordinaten gespeichert, die der skalierten Version der Kurve entsprechen.

Anschließend werden die Skalierungsfaktoren berechnet:

• x_scale wandelt den Bereich der x-Werte in die verfügbare Breite der Leinwand um (wobei auf jeder Seite ein Rand von 20 Pixeln verbleibt).
• y_scale wandelt den Bereich der y-Werte in die verfügbare Leinwandhöhe um (auch mit Rändern). Um sicherzustellen, dass die Kurve ihr Seitenverhältnis beibehält (damit sie nicht gestreckt oder verzerrt wird), wird der kleinere dieser beiden Skalierungsfaktoren als endgültiger Skalierungswert gewählt.

Schließlich wird jeder Datenpunkt in Leinwandkoordinaten umgewandelt.

Die Formel übersetzt die mathematischen x-y-Werte in Bildschirmpositionen, wobei die Ränder berücksichtigt werden und die Y-Achse invertiert wird (da die Leinwandkoordinaten in der linken oberen Ecke beginnen). Am Ende dieses Prozesses sind alle Butterfly-Kurven-Datenpunkte richtig skaliert und im sichtbaren Bereich der Leinwand positioniert, sodass sie gezeichnet werden können.

   // Draw the curve
   canvas.Erase(ColorToARGB(clrWhite, 255)); // White background
   
   // Set line color - we'll pass this directly to Line() method
   uint line_color = ColorToARGB(clrBlue, 255);
   
   // Draw the polyline
   for(int i = 1; i < points; i++)
     {
      canvas.Line(x_px[i-1], y_px[i-1], x_px[i], y_px[i], line_color);
     }
   
   // Title
   canvas.FontSet("Arial", 20, FW_BOLD);
   canvas.TextOut(300, 20, "Butterfly Curve", ColorToARGB(clrBlack, 255));
   
   // Update display
   canvas.Update();

Dieser Abschnitt des Codes konzentriert sich auf das Rendern und Gestalten der endgültigen Butterfly-Kurve auf der Leinwand. Wir konfigurieren den visuellen Stil des Diagramms, indem wir den Hintergrund der Leinwand auf weiß und die Datenlinie auf blau setzen. Die Datenpunkte von x_px und y_px werden dann aufgetragen. Schließlich setzen wir die Schriftart des Titels auf 20-Punkt Arial in Schwarz und aktualisieren die Leinwand, um die endgültige Visualisierung anzuzeigen.

Die Entwicklung der Butterfly-Oszillation

Um den Butterfly-Oszillation zu konstruieren, verwenden wir die x-Komponente der Butterfly-Kurve aufgrund ihrer symmetrischen Eigenschaft. Die x-Komponente ist von Natur aus im Bereich [-3, +3] begrenzt und eignet sich daher ideal für die Erstellung eines Oszillators.

Um dies für den Handel zu adaptieren, definieren wir den Eingabeparameter t einfach als die verstrichene Anzahl von Kursbalken. Da t die Anzahl der Balken darstellt, ist die Kurve über alle Zeitrahmen hinweg identisch. Die zugrunde liegende Gleichung ist zyklisch, weshalb der Oszillator wellenartige Muster bildet, die sich nach jedem vollständigen Zyklus wiederholen.

Ein vollständiger Zyklus der zugrundeliegenden Butterfly-Kurve tritt bei t=24π auf, was etwa 75,4 bar entspricht. Um die Empfindlichkeit des Oszillators zu steuern, führen wir eine Schrittweite (Δt) als Skalierungsfaktor ein, wobei die Anzahl der für einen vollständigen Oszillatorzyklus erforderlichen Balken (N) wie folgt berechnet wird:  N = 24π / Δt

Beispiele:

• Schrittweite = 1:     N=24π/1=76 Balken (vollständiger Zyklus)
• Schrittweite = 0,5:  N=24π/0,5=151 Balken
• Schrittweite = 5:     N=24π/5=15 Balken

Die Schrittweite hat einen direkten Einfluss auf das Verhalten des Oszillators:

• Kleinere Schrittweiten erzeugen glattere und langsamere Wellenformen.
• Größere Schrittweiten erzeugen schnellere und häufigere Schwingungen.

Dadurch können Händler den Oszillator entweder für die Erkennung langfristiger Muster oder für kurzfristige Zyklusanalysen anpassen.

Den Oszillator preisreaktiv machen:

Der Oszillator kann rein auf der Basis der Balkenanzahl arbeiten, er kann aber auch auf die Kursbewegung reagieren. Zu diesem Zweck wird die Differenz zwischen dem Schluss- und dem Eröffnungskurs der Kerze herangezogen. Diese Anpassung ermöglicht es dem Oszillator, auf Veränderungen in der Preisdynamik zu reagieren, sodass er sich besser an die Marktvolatilität in Echtzeit anpassen kann und nicht nur von der zeitlichen Entwicklung abhängig ist.

Dieses hybride Design – eine Kombination aus zyklischem Verhalten und Preissensitivität – ermöglicht es dem Butterfly-Oszillator, sowohl strukturelles Timing als auch momentumbasierte Bestätigung zu liefern.

Bevor wir zeigen, wie der Oszillator in der Praxis funktioniert, wollen wir kurz die Codestruktur skizzieren, mit der er implementiert wurde. 

//--- plot Butterfly
#property indicator_label1  "Butterfly Oscillator"
#property indicator_type1   DRAW_LINE
#property indicator_color1  DodgerBlue
#property indicator_width1  2
#property indicator_style1  STYLE_SOLID

//--- indicator levels
#property indicator_level1  2.5
#property indicator_level2 -2.5
#property indicator_level3  0.0

In diesem Abschnitt des Codes werden die visuellen und strukturellen Eigenschaften des Butterfly-Oszillation festgelegt. Hier wird festgelegt, wie der Indikator im Chart angezeigt wird. Standardmäßig wird eine durchgezogene blaue Linie mit der Bezeichnung „Butterfly-Oszillator“ und einer Stärke von 2 verwendet, um eine klare Sichtbarkeit zu gewährleisten. Darüber hinaus werden die wichtigsten Referenzwerte auf 2,5, -2,5 und 0,0 festgelegt. Insgesamt sorgen diese Einstellungen dafür, dass der Oszillator visuell deutlich und analytisch nützlich für die Identifizierung von Marktzyklen ist.

//--- input parameters
input bool   UsePriceStep = false; // Use ClosePrice as Step size for t increment
input double tmStep       = 0.05;  // Step size for t increment

In diesem Abschnitt werden Nutzereingabeparameter definiert, die steuern, wie der Butterfly-Oszillator seine Zeitschritte berechnet.

• UsePriceStep: Eine boolesche Option, mit der der Nutzer wählen kann, ob die Schrittgröße auf der Preisbewegung anstelle einer Anzahl von Balken basieren soll.
• tmStep: Eine numerische Eingabe, die die feste Schrittweite für die Inkrementierung der Variablen t festlegt.

Diese Eingaben geben Händlern die Flexibilität, einzustellen, wie sanft oder empfindlich der Oszillator auf Marktveränderungen reagiert. Die gewählte Schrittweite hat großen Einfluss auf das Verhalten und die Gesamtdynamik des Oszillators.

double CalButterflyValue(int bar_index, double bar_close, double bar_open)
  {
   double tStep = UsePriceStep ? MathMod((bar_close - bar_open) / _Point, tmStep) : tmStep;
   double t = bar_index * tStep;

   // Butterfly curve formula
   double x = MathSin(t) *
              (MathExp(MathCos(t)) - 2.0 * MathCos(4.0 * t) - MathPow(MathSin(t / 12.0), 5));

   return (x);
  }

In diesem Abschnitt wird die Funktion Butterfly definiert, die den Wert des Oszillators für jeden Balken des Charts berechnet.

Die Funktion CalButterflyValue() benötigt drei Parameter:

• bar_index – die Position des aktuellen Balkens im Chart,
• bar_close – der Schlusskurs des betreffenden Balkens, und
• bar_open – der Eröffnungskurs des betreffenden Balkens.

Innerhalb der Funktion wird eine Schrittweite (tStep) berechnet. Wenn UsePriceStep aktiviert ist, erfolgt eine dynamische Anpassung auf der Grundlage von Preisbewegungen; andernfalls wird der feste tmStep-Wert verwendet. Die Variable t wird dann aus dem Balkenindex und der Schrittweite abgeleitet.

Schließlich wird die Butterfly-Kurvenformel angewandt, um x zu berechnen, das den Wert des Oszillators an diesem Balken darstellt. Dieser Wert gibt die mathematische Form der Butterfly-Kurve an und wird zur Darstellung im Chart zurückgegeben.

   int pStart = prev_calculated == 0 ? 0 : prev_calculated - 1;

   for(int i = pStart; i < rates_total; i++)
     {
      double bar_close = close[i];
      double bar_open  = open[i];
      ButterflyBuffer[i] = CalButterflyValue(i, bar_close, bar_open);
     }

Dieser Abschnitt initialisiert und füllt den Puffer des Butterfly-Oszillators mit berechneten Werten für die Chartdarstellung.

Die Variable pStart bestimmt, wo die Berechnung beginnen soll – beim ersten Durchlauf bei Null, bei späteren Aktualisierungen zur Verbesserung der Effizienz beim letzten berechneten Balken. Jeder berechnete Wert wird in dem Array ButterflyBuffer gespeichert, das später zur Darstellung der Oszillatorlinie im Indikatorfenster verwendet wird.

Demonstration des Butterfly-Oszillatiors

In unserer Demonstration des Butterfly-Oszillators untersuchen wir sein Verhalten unter zwei Bedingungen: bei ausschließlicher Verwendung der Balkenzählung und bei Verwendung der Balkenzählung in Kombination mit der Preisbewegung. Dieser Vergleich ermöglicht es uns zu beobachten, wie der Oszillator in jedem Szenario reagiert.

Fall 1: Die Auswirkung der Schrittweite (nur Balkenanzahl)

Abbildung 2 veranschaulicht den Oszillator, wenn er ausschließlich durch die Balkenzahl gesteuert wird. In diesem Fall ist der Parameter UsePriceAction auf false gesetzt, was bedeutet, dass nur die Anzahl der Balken den Verlauf des Oszillators bestimmt. Drei verschiedene Schrittweiten – 0,05, 0,5 und 5 – werden verwendet, um ihre Auswirkungen auf die Wellenform zu untersuchen.

Abbildung 2: Butterfly-Oszillation ohne Kursbewegung

Aus dem Chart lässt sich Folgendes ablesen:

• Wenn die Schrittweite klein ist (z. B. 0,05), braucht der Oszillator länger, um einen vollen Zyklus zu vollenden, wodurch eine sanftere und allmählichere Welle entsteht.
• Wenn die Schrittweite groß ist (z. B. 5), schließt der Oszillator seinen Zyklus viel schneller ab, was zu einem schärferen und unregelmäßigeren Muster führt.

Dies zeigt, dass die Schrittgröße die Glätte und Frequenz des Oszillators direkt steuert – kleinere Schritte betonen langfristige zyklische Bewegungen, während größere Schritte kurzfristige Schwankungen hervorheben.

Fall 2: Die Auswirkung der Schrittgröße (mit Kursbewegung)

Abbildung 3 veranschaulicht das Oszillatormuster, wenn es von der Preisentwicklung gesteuert wird. In diesem Fall wird das Verhalten des Oszillators nicht nur von der Schrittweite, sondern auch von den Marktpreisbewegungen beeinflusst. Ähnlich wie im Balkenzählmodus bewegt sich der Oszillator bei größeren Schrittweiten schneller und bei kleineren Schrittweiten langsamer. Im Gegensatz zum vorherigen Fall wird die Kurve durch die Einbeziehung der Preisentwicklung jedoch variabler.

Abbildung 3: Butterfly-Oszillator, gesteuert durch die Preisbewegung

Da die Preisentwicklung zu chaotischen und nichtlinearen Bewegungen neigt, spiegeln sich ihre Schwankungen in der Form des Oszillators wider. Infolgedessen wird der Butterfly-Oszillator dynamischer und passt seine Wellenform an die zugrunde liegende Marktvolatilität an, anstatt einem rein mathematischen Rhythmus zu folgen.

Butterfly-Oszillator Handelsstrategie

Nachdem wir nun den Butterfly-Oszillator-Indikator erfolgreich entwickelt haben, können wir einen einfachen Butterfly Expert Advisor (EA) erstellen, der diesen Indikator als Einstiegskriterium verwendet. Die Handelsstrategie wurde entwickelt, um zyklische Wendepunkte im Oszillator zu erkennen und sie mit dem breiteren Markttrend, der durch den gleitenden Durchschnitt (MA) angezeigt wird, in Einklang zu bringen.

In diesem Ansatz definieren wir zwei Strategien für den Markteintritt:

Strategie 1

• Kaufsignal: Wenn der gleitende Durchschnitt (MA) einen Aufwärtstrend anzeigt und der Butterfly-Oszillator über +2,5 kreuzt, eröffnen Sie eine Kaufposition.
• Verkaufssignal: Wenn der MA einen Abwärtstrend anzeigt und der Butterfly-Oszillator über +2,5 kreuzt, eröffnen Sie eine Verkaufsposition.

Strategie 2

• Kaufsignal: Wenn der MA einen Aufwärtstrend anzeigt und der Butterfly-Oszillator unter -2,5 fällt, eröffnen Sie eine Kaufposition.
• Verkaufssignal: Wenn der MA einen Abwärtstrend anzeigt und der Butterfly-Oszillator unter -2,5 fällt, eröffnen Sie eine Verkaufsposition.

Bei beiden Strategien dient die MA-Trendrichtung als Trendfilter, während der Butterfly-Oszillator als Einstiegstrigger fungiert.

• Strategie 1 konzentriert sich auf Signale mit oberem Schwellenwert (+2,5), die in der Regel den Spitzenwert der Oszillatorzyklen anzeigen.
• Strategie 2 konzentriert sich auf Signale mit einem niedrigeren Schwellenwert (-2,5), um den Tiefpunkt des Zyklus zu erfassen.

Der Butterfly EA bietet Flexibilität, indem er Händlern die Möglichkeit gibt, zwischen Strategie 1 und Strategie 2 zu wählen oder beide nacheinander auszuführen. Der EA enthält auch eine Option, mit der Sie festlegen können, ob der Butterfly-Oszillator auf Kursbewegungen reagieren oder sich ausschließlich auf die Progression der Balkenzählung verlassen soll.

Die relevanten Eingabeparameter sind wie folgt definiert:

//--- Strategy Selection
input bool UsePriceStep = false;      // Use ClosePrice 
input bool EnableStrategy1 = true;    // Enable Strategy 1 Peak
input bool EnableStrategy2 = false;   // Enable Strategy 2 Trough

UsePriceStep – Aktiviert oder deaktiviert den Preisaktionsmodus.

• Wenn diese Option auf „true“ gesetzt ist, bezieht der EA die Preisbewegung (Close-Open-Differenz) in das Verhalten des Oszillators ein, sodass er auf die Marktdynamik reagiert.
• Bei der Einstellung false verlässt sich der Oszillator ausschließlich auf die Balkenzählung und behält ein festes zyklisches Muster bei.

Auswahl der Strategie:

• Strategie 1 ist so konzipiert, dass sie Signale auf der Grundlage der Peak-Formationen des Oszillators erzeugt.
• Die Strategie 2 ist so konzipiert, dass sie Signale auf der Grundlage ihrer Tiefs erzeugt.

Wenn sowohl Strategie 1 als auch Strategie 2 aktiv sind, gibt der EA derjenigen Schwellenwertbedingung den Vorrang, die während der Marktausführung zuerst ausgelöst wird.

Um ein diszipliniertes Handelsmanagement zu gewährleisten, ist der EA so konzipiert, dass er nur eine offene Position zur gleichen Zeit zulässt. Dadurch wird verhindert, dass widersprüchliche Handelsgeschäfte gleichzeitig ausgeführt werden, und die Klarheit bei der Bewertung der Strategieleistung bleibt erhalten.

Die zentrale Handelslogik für den Butterfly EA ist wie folgt implementiert:

   //--- Strategy 1: Peak
   if(EnableStrategy1 && prevValue < 2.5 && currValue > 2.5)
   {
      if(maFast > maSlow)
         OpenBuy();
      else if(maFast < maSlow)
         OpenSell();
   }

   //--- Strategy 2: Trough
   if(EnableStrategy2 && prevValue > -2.5 && currValue < -2.5)
   {
      if(maFast > maSlow)
         OpenBuy();
      else if(maFast < maSlow)
         OpenSell();
   }

Strategie 1 (hohe Spitze):

Wenn der vorherige Wert des Butterfly-Oszillators unter +2,5 liegt und der aktuelle Wert über +2,5 steigt, wird ein Signal erzeugt.

• Wenn der schnelle MA über dem langsamen MA liegt, deutet dies auf einen Aufwärtstrend hin, und ein Kaufauftrag wird ausgeführt.
• Wenn der schnelle MA unter dem langsamen MA liegt, deutet dies auf einen Abwärtstrend hin, und es wird ein Verkaufsauftrag erteilt.

Strategie 2 (tiefe Spitze):

Wenn der vorherige Wert des Butterfly-Oszillators über -2,5 liegt und der aktuelle Wert unter -2,5 fällt, wird ein Signal erzeugt.

• Wenn der schnelle MA über dem langsamen MA liegt, interpretiert der EA dies als einen Aufwärtstrend, und ein Kaufauftrag wird ausgeführt.
• Wenn der schnelle MA unter dem langsamen MA liegt, was auf einen Abwärtstrend hinweist, wird ein Verkaufsauftrag erteilt.

Testen des Butterfly-Oszillator EA:

Um den EA an die individuellen Handelspräferenzen und Risikomanagementregeln anzupassen, wird ein umfassender Satz von Eingabeparametern bereitgestellt. Diese Einstellungen sind der Übersichtlichkeit halber kategorisiert und ermöglichen es dem Nutzer, das Handelsmanagement, das Verhalten der Indikatoren und die Strategieauswahl zu steuern.

Abbildung 4: EA-Eingabeparameter

Strategieprüfung und Demonstration von Einstiegssignalen:

• Step Size : 0.3:

Um die vom Butterfly EA generierten Einstiegssignale zu demonstrieren, haben wir Strategie 1 mit einer Schrittweite von 0,3 getestet.

Abbildung 5 veranschaulicht die resultierenden Kauf- und Verkaufssignale, die bei dieser Konfiguration erzeugt werden. Mit einer größeren Schrittweite schließt der Butterfly-Oszillator seinen Zyklus über weniger Balken ab, wodurch er seine Höchst- und Tiefststände schneller erreicht. Infolgedessen erzeugt der EA häufiger Einstiegssignale innerhalb einer kürzeren Zeitspanne.

Abbildung 5: Strategie 1 mit Schrittweite =0,3

• Step Size : 0.03:

Mit einer Schrittweite von 0,03 haben wir das Verhalten des Butterfly Expert Advisors bei Strategie 1 weiter untersucht.

Abbildung 6 zeigt die Kauf- und Verkaufssignale, die mit dieser kleineren Schrittweite erzeugt wurden. Wenn die Schrittweite klein ist, benötigt der Butterfly-Oszillator mehr Balken, um einen vollen Zyklus abzuschließen. Folglich erreicht er seine Höchst- und Tiefststände langsamer, was dazu führt, dass im gleichen Zeitraum weniger Einstiegssignale erzeugt werden.

Abbildung 6: Strategie 1 mit Schrittweite =0,03

Dieses Verhalten verdeutlicht den direkten Einfluss der Schrittgröße auf die Häufigkeit der Handelssignale – größere Werte führen zu schnelleren Schwingungen und mehr Handelsgeschäfte, während kleinere Werte langsamere, gleichmäßigere Zyklen mit weniger, aber stabileren Signalen erzeugen.

Schlussfolgerung

In diesem Artikel haben wir das Konzept der Butterfly-Kurve verwendet, um einen Oszillator und eine Handelsstrategie zu entwickeln. Der Butterfly-Oszillator hat gezeigt, wie mathematische Muster an die Marktdynamik angepasst werden können und so einzigartige Einblicke in die Kursentwicklung ermöglichen. Durch die Variation der Schrittweite konnten wir beobachten, wie sich die Glätte und die Signalfrequenz des Oszillators verändern und wie diese Eigenschaften in Kombination mit gleitenden Durchschnittstrends den Einstieg in den Handel beeinflussen können.

Der entwickelte Butterfly EA setzte den Oszillator erfolgreich als Einstiegskriterium ein und bot zwei unterschiedliche Strategien an – eine für hohe und eine für tiefe Spitzen – die jeweils sowohl auf die Marktrichtung als auch auf die Schwellenwerte des Oszillators reagierten.

In unserem nächsten Artikel werden wir mit verschiedenen Instrumenten experimentieren, um die Stärken und Schwächen dieses Konzepts zu testen. Wir werden weiter mit diesem neuen Oszillator in Kombination mit anderen Oszillatoren experimentieren, um unsere Einstiegsstrategie zu verfeinern. Bleiben Sie dran für weitere Einstiegstipps und Erweiterungen des Butterfly-Handelssystems.

Datei	Beschreibung
ButterflyPlot.mq5	Diese Skriptdatei ist für die Erzeugung und Anzeige der Butterfly-Kurve im aktiven Chart-Fenster unter Verwendung ihrer definierten mathematischen Funktion verantwortlich. Wenn das Skript ausgeführt wird, stellt es die Kurve visuell im Chartfenster dar. Sobald die Butterfly-Kurve gezeichnet ist, bleibt sie im Chart als Teil der aktuellen visuellen Ebene angezeigt. Die von diesem Skript erzeugte Kurve kann nur gelöscht oder entfernt werden, wenn die Vorlage des Charts geändert oder auf eine neue Vorlage aktualisiert wird.
ButterflyOscillator.mq5	Diese Datei definiert den Butterfly-Indikator, der in einem separaten Unterfenster unter dem Handelschart angezeigt werden soll.
ButterflyOscillatorEA.mq5	Diese Datei definiert einen Expert Advisor, der den Butterfly-Oszillator nutzt, um automatisch Handelspositionen auf der Plattform zu eröffnen und zu verwalten.