Entwicklung einer Handelsstrategie: Der Flower-Volatilitäts-Index als Trendfolgemethode

Einführung

Die Finanzmärkte bewegen sich im Rhythmus von Expansion und Kontraktion, Beschleunigung und Verlangsamung, Trendbildung und zyklischer Rotation. Händler versuchen seit langem, diesen Rhythmus mathematisch zu modellieren, indem sie Indikatoren entwickeln, die helfen, Einstiegsmöglichkeiten zu definieren, die Trendrichtung zu erkennen oder zu signalisieren, wenn sich die Preise zu weit vom Gleichgewicht entfernt haben. Diese preisbasierten mathematischen Modelle, die allgemein als technische Indikatoren bekannt sind, werden je nach Zielsetzung des Händlers unterschiedlich interpretiert.

Im Laufe der Jahre haben sich mehrere Indikatoren für die Abbildung von Zyklen und Trends oder überzogenen Bedingungen bewährt, darunter der Commodity Channel Index (CCI), der Force Index, der Bull and Bear Power, der Relative Vigor Index (RVI), die Cycle Lines und die Fibonacci Time Zones. Jede bietet einen einzigartigen Einblick in die Marktstruktur.

In diesem Artikel stellen wir eine Trendfolgestrategie vor, die von einer klassischen mathematischen Funktion, der Rosenkurve, abgeleitet ist. Die Rosenkurve wurde ursprünglich von dem italienischen Mathematiker Guido Grandi (1671-1742) erforscht und erzeugt geometrische, blumenähnliche Muster – daher auch ihr Name. Durch die Neudefinition seiner Parameter konstruieren wir einen neuen Oszillator, den Flower Volatility Index (FVI), und bauen um ihn herum einen Rahmen für den Trendhandel auf.

Die mathematische Grundlage: Die Rosenkurve

Die Rosenkurve wird durch die Polargleichung definiert:

Die Zerlegung dieser radialen Funktion ergibt die kartesischen Komponenten:

Aufgrund ihrer Eigenschaften eignet sich die Funktion hervorragend zur Erstellung eines technischen Indikators. Sein Verhalten wird durch das rationale Verhältnis n/d bestimmt, das die Form, Symmetrie und Periodizität der resultierenden Darstellung vorgibt. Diese Komponenten bilden die Grundlage, auf der wir den Flower Volatility Index konstruieren. Bevor diese Funktion auf Marktdaten angewandt wird, ist es sinnvoll, die ihr innewohnenden Eigenschaften zu untersuchen.

Die nachstehenden Abbildungen 1 bis 3 zeigen beispielhafte radiale Darstellungen der Rosenkurve und verdeutlichen deren Vielseitigkeit:

Abbildung 1: N=20 , d=1

Abbildung 2: N=17, d=1

Abbildung 3: N=20, d=7

Zu den wichtigsten Beobachtungen, die sich aus diesen radialen Diagrammen ergeben, gehören:

• Vielfalt der Muster: Das Verhältnis n/d erzeugt eine breite Palette von Mustern. Ein Verhältnis von 1/2 ergibt einen einfachen Kreis, während höhere Verhältnisse zu komplizierteren, mehrblättrige Mustern führen.

• Anzahl der Blütenblätter: Der Schlüsselparameter j = n/(2d) bestimmt die Anzahl der Blütenblätter oder Flügel.

• Wenn j eine ganze Zahl und ungerade ist, hat die Kurve j Blütenblätter. Wenn j eine ganze Zahl und gerade ist, entstehen 2j Blütenblätter. Zum Beispiel: n=6, d=3, dann j=1, also 1 Blütenblatt. n = 16, d = 2, dann j=4, also 8 Blütenblätter.

• Wenn j rational, aber nicht ganzzahlig ist, ergeben sich komplexere und unvollständige Blütenblattmuster.

• Sonderfall: n =d ergibt kardioidähnliche Formen

• Symmetrie und Oszillation: Die Kurven weisen eine durchgängige Rotations- und Reflexionssymmetrie auf. Entscheidend ist, dass die Amplitude immer zwischen -1 und 1 oszilliert, was ihn zu einem idealen Kandidaten für einen begrenzten Oszillator macht, aus dem ein Händler die Komponenten (X oder Y) auswählen kann, die seinen strategischen Bedürfnissen am besten entsprechen.

Überprüfung der Codestruktur für die Rosenkurve

Um mit der Erstellung der Rosenkurve zu beginnen, ist der erste wichtige Schritt die Einbindung der Canvas-Bibliothek, die alle notwendigen Eigenschaften und Funktionen für die Darstellung von grafischen Objekten im Chart bereitstellt. Diese Bibliothek dient als Grundlage für das Zeichnen, Darstellen und Verwalten visueller Elemente innerhalb des Indikators oder Skripts.

#include <Canvas\Canvas.mqh>


// Create canvas for drawing
int width = 800;   // Canvas width
int height = 600;  // Canvas height
string canvas_name = "FlowerCurve";

Nach dem Importieren der Canvas-Bibliothek legen wir die Abmessungen der Zeichenfläche fest. In diesem Beispiel sind die Breite und Höhe der Leinwand auf 800 bzw. 600 Pixel festgelegt.

Der Leinwand wird auch ein identifizierbarer Name zugewiesen, „FlowerCurve“, der es der Plattform ermöglicht, die Zeichenfläche zu referenzieren und zu verwalten.

Innerhalb der Funktion CurvePlotting beginnt der Prozess der Erstellung der Blumenkurve (Rose) mit der Erstellung des Canvas-Objekts. Dieses Objekt dient als Zeichenfläche und wird unter Verwendung des vordefinierten Canvas-Namens, seiner Position im Chart, der Rahmengröße und des gewählten Farbformats konfiguriert. Wenn die Initialisierung des Canvas fehlschlägt, wird eine Fehlermeldung ausgegeben, und die Funktion wird ordnungsgemäß beendet.

   // Create canvas object
   CCanvas canvas;
   if(!canvas.CreateBitmapLabel(canvas_name, 200, 50, width, height, COLOR_FORMAT_XRGB_NOALPHA))
     {
      Print("Error creating canvas: ", GetLastError());
      return;
     }

   // Set up drawing parameters
   int points = 1000;           // Number of points
   double t_start = -2 * M_PI;           // Start angle
   double t_end = 2 * 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 rad = MathSin((n*t)/(2*d));
      y[i] = MathSin(t) * rad;
      x[i] = MathCos(t) * rad;
     }

Sobald der Canvas erfolgreich erstellt wurde, fährt die Funktion mit der Einstellung der für das Plotten erforderlichen Parameter fort. Dazu gehört die Festlegung der Gesamtzahl der zu berechnenden Punkte sowie die Angabe des Start- und Endwinkels für die Kurve. Ein Schrittwert wird berechnet, um die Winkelschritte gleichmäßig über das definierte Intervall zu verteilen.

Nachdem diese Parameter festgelegt wurden, initialisiert die Funktion Arrays, um die x- und y-Koordinaten der Kurve zu speichern. Anschließend wird jeder Punkt durchlaufen, wobei der Winkel t berechnet und die mathematischen Ausdrücke, die die Blumenkurve definieren, ausgewertet werden.

Nach der Berechnung der rohen x- und y-Datenpunkte für die Blumenkurve besteht die nächste Aufgabe der Funktion CurvePlotting darin, diese Koordinaten so zu skalieren, dass die gesamte Kurve genau in den Canvas-Bereich passt. Dies umfasst mehrere Schritte, beginnend mit der Ermittlung der Mindest- und Höchstwerte für x und y. Diese Grenzen sind wichtig, um zu bestimmen, wie die Proportionen der Kurve geändert werden sollen.

   // 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) + 30;
      y_px[i] = height - (int)((y[i] - y_min) * scale) - 20; // Flip Y-axis for canvas coordinates
     }

Nachdem die Extremwerte ermittelt wurden, erstellt die Funktion ganzzahlige Arrays (x_px und y_px), die die transformierten Pixelkoordinaten enthalten werden. Die Skalierungsfaktoren für beide Achsen werden dann auf der Grundlage der verfügbaren Zeichenfläche berechnet (wobei Ränder belassen werden, um ein Berühren der Ränder der Leinwand zu vermeiden). Um die Form der Kurve ohne Verzerrung zu erhalten, wird der kleinere der beiden Skalierungswerte als einheitlicher Skalierungsfaktor gewählt.

Schließlich wird jeder Punkt von mathematischen Koordinaten in Leinwandkoordinaten umgewandelt. Die x-Werte werden nach rechts verschoben, um einen Rand zu schaffen, während die y-Werte invertiert werden – da die Leinwandkoordinaten nach unten ansteigen – um sicherzustellen, dass die gezeichnete Kurve korrekt ausgerichtet ist.

Der letzte Schritt der Funktion CurvePlotting besteht darin, die Blumenkurve auf die Leinwand zu übertragen. Dies beginnt mit der Einstellung der Hintergrundfarbe, um sicherzustellen, dass die Zeichenfläche sauber und optisch ansprechend ist. In dieser Implementierung wird ein GhostWhite-Hintergrund verwendet, um einen weichen Kontrast zur Kurve zu schaffen.

Als Nächstes wird die Linienfarbe festgelegt. Ein vollständig undurchsichtiger Blau-Violett-Ton wird ausgewählt, und sein ARGB-Wert wird direkt an die Methode zum Zeichnen von Linien auf der Leinwand übergeben. Die Kurve selbst wird als Polylinie gezeichnet, indem zwischen jedem Paar skalierter Datenpunkte aufeinanderfolgende Liniensegmente eingezeichnet werden.

   // Draw the curve
   canvas.Erase(ColorToARGB(clrGhostWhite, 255)); // GhostWhite background

   // Set line color - we'll pass this directly to Line method
    uint line_color = ColorToARGB(clrBlueViolet, 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);
     }
   
   // Add title
   canvas.FontSet("Cambria", 20, FW_BOLD);
   canvas.TextOut(300, 20, "Flower Curve: n=", ColorToARGB(clrBlack, 255));
   canvas.TextOut(445, 20, IntegerToString(n), ColorToARGB(clrBlack, 255));

   canvas.TextOut(470, 20, "&  d=", ColorToARGB(clrBlack, 255));
   canvas.TextOut(520, 20, IntegerToString(d), ColorToARGB(clrBlack, 255));
   
   // Update display
   canvas.Update();

Um die visuelle Darstellung zu vervollständigen, legt die Funktion den Schriftstil, die Größe und die Gewichtung fest. Aus Gründen der Übersichtlichkeit wurde eine fette Cambria-Schrift in Größe 20 gewählt. Der Titel der Kurve wird dann am oberen Rand der Leinwand mit canvas.TextOut gerendert und zeigt dynamisch die aktuellen Werte von n und d an, die bei der Erstellung der Blumenkurve verwendet wurden.

Sobald alle Elemente gezeichnet wurden, wird die Methode canvas.Update() aufgerufen, um die Anzeige zu aktualisieren und alle gerenderten Komponenten im Chart sichtbar zu machen.

Automatisieren der Kurvengenerierung in der Startfunktion 

In der Funktion Start wird der Plotvorgang automatisiert, indem die Funktion CurvePlotting in eine Schleife eingefügt wird. Mit dieser Struktur kann die Blumenkurve für verschiedene Kombinationen der Eingabeparameter n und d dynamisch dargestellt werden. Durch die Anpassung dieser Parameter kann das Skript eine Vielzahl von Kurvenformen anzeigen, die jeweils einzigartige mathematische Eigenschaften widerspiegeln.

   int p=1;
   while (p<=nLimit) 
    {
    
     CurvePlotting(p);
     p++;
     Sleep(1000);

Sowohl n als auch d sind als nutzerdefinierte Eingabeparameter verfügbar. Dies gibt dem Händler oder Analysten die volle Kontrolle über die Anpassung der Geometrie der Blumenkurve, ohne den Kerncode zu verändern. Wenn das Programm ausgeführt wird, durchläuft es die angegebenen Werte und ruft CurvePlotting für jedes Paar auf. Dies ermöglicht eine nahtlose Visualisierung mehrerer Kurvenmuster direkt auf dem Chart.

Von der Geometrie zum Marktindikator: Konstruktion des Flower Volatility Index

Vor der Entwicklung des Flower Volatility Index (FVI) Oszillators ist es aufschlussreich, die kartesischen Komponenten der Rosenkurve zu untersuchen. Übersetzt man die polare Funktion in X- und Y-Komponenten, so wird ihr oszillatorischer Charakter in einer Form deutlich, die den Händlern vertrauter ist.

Die Abbildungen 4 bis 7 zeigen die X- und Y-Komponenten der Rosenkurvenfunktion im Zeitverlauf für verschiedene Werte von n und d: Das rote Diagramm stellt die X-Komponente und das blaue Diagramm die Y-Komponente der Rosenkurve dar, jeweils aufgetragen gegen den Winkel.

Abbildung 4 : Rosenwelle: n=5, d=1

Abbildung 5: Rosenwelle: n=1, d=1

Abbildung 6: Rosenwelle: n=5, d=7

Abbildung 7: Rosenwelle: n=20, d=8

Abbildung 8: Rosenwelle: n=7, d=4

Die Analyse dieser kartesischen Diagramme zeigt kritische Merkmale für finanzielle Anwendungen:

• Begrenzte Oszillation: Beide Komponenten oszillieren durchweg zwischen -1 und 1, was eine natürliche Grenze für überkaufte und überverkaufte Kurse darstellt.
• Frequenzkontrolle: Mit den Parametern n und d lässt sich die Frequenz der Schwingung genau steuern. Höhere n-Werte erhöhen die Frequenz, während höhere d-Werte sie verringern.
• Vorhersehbare Periodizität: Die Periode der Schwingung ist gegeben durch T = 4πd/n. Dies ermöglicht eine strategische Abstimmung: Ein kleines n/d-Verhältnis führt zu längeren, gleichmäßigeren Zyklen, die sich ideal zum Erfassen wichtiger Trends eignen, während ein großes Verhältnis kürzere, reaktivere Zyklen erzeugt.

Sonderfälle zeigen seine Flexibilität:

• Wenn n = d ist, vereinfacht sich die Funktion zu r(q) = sin(q/2), einer einfachen Sinuswelle.
• Wenn n = 2d ist, wird r(q) = sin(q), eine Standard-Sinuswelle.

Vorbereiten des Plots der kartesischen Koordinaten

Bevor die kartesische Form der Kurve erzeugt wird, müssen die notwendigen grafischen Werkzeuge geladen werden. Dies wird durch die Einbindung der Grafikbibliothek erreicht, die alle wesentlichen Funktionen zum Plotten, Rendern und Verwalten visueller Elemente innerhalb der Chartumgebung bereitstellt. Die Bibliothek dient als Grundgerüst für das Zeichnen der x-y-Komponenten der Blumenkurve.

Sobald die Bibliothek eingebunden ist, wird ein grafischer Objektname definiert. In diesem Fall wird die Zeichenfläche als „PetalPlot“ identifiziert, sodass das Programm den grafischen Bereich während des Renderings referenzieren und kontrollieren kann.

#include <Graphics/Graphic.mqh>

string g_name = "PetalPlot";

Um das Chart für die Darstellung der kartesischen Komponenten der Blumenkurve vorzubereiten, wird eine spezielle Funktion – SetupChartQX – definiert. Diese Funktion kapselt alle wesentlichen Konfigurationsschritte, die für eine saubere, lesbare und visuell strukturierte Darstellungsumgebung erforderlich sind. Durch die Zentralisierung dieser Einstellungen wird das Chart jedes Mal, wenn eine neue Kurve gerendert wird, einheitlich formatiert.

Die Funktion beginnt mit der Einstellung eines weißen Hintergrunds, um eine neutrale Leinwand für die grafischen Elemente zu schaffen. Anschließend konfiguriert er beide Achsen:

• Die X-Achse reicht von -2π bis 2π und ist mit q beschriftet.
• Die Y-Achse reicht von -1,2 bis 1,2 und ist mit x beschriftet.

void SetupChartQX(CGraphic &graphic)
{
   // Set background color
   graphic.BackgroundColor(clrWhite);
         
   // Configure X axis
   graphic.XAxis().Min(-2*M_PI);
   graphic.XAxis().Max(2*M_PI);
   graphic.XAxis().Name("q");
   
   // Configure Y axis
   graphic.YAxis().Min(-1.2);
   graphic.YAxis().Max(1.2);
   graphic.YAxis().Name("x");
   
   // Add grid
   graphic.XAxis().Color(clrGray);
   graphic.YAxis().Color(clrGray);
   
   // Increase font sizes
   graphic.XAxis().ValuesSize(14);
   graphic.YAxis().ValuesSize(14);
   graphic.XAxis().NameSize(16);
   graphic.YAxis().NameSize(16);
   
   // Add title
   graphic.CurvePlotAll();
   graphic.Update();
}

Diese Bereiche stellen sicher, dass die gesamte Variation der Eingangsfunktion ohne Überschneidung angezeigt werden kann.

Gitternetzlinien werden hinzugefügt, indem die Achsenfarben auf grau gesetzt werden, was die Lesbarkeit verbessert und den Nutzern hilft, die Position der Kurve relativ zu den Achsen visuell zu interpretieren. Um die Übersichtlichkeit weiter zu erhöhen, wurde die Schriftgröße für Achsenwerte und Achsennamen erhöht.

Schließlich ruft die Funktion CurvePlotAll() gefolgt von Update() auf, um das Chart für die Anzeige von Kurvendaten vorzubereiten. 

Die Funktion PlotQX() dient dazu, alle Darstellungsoperationen für die X-Komponente der Rosenkurve durchzuführen. Diese Funktion dient als zentraler Motor, der für die Erzeugung der Datenpunkte, die Anwendung der erforderlichen Transformationen und die Darstellung des Ergebnisses im Chart verantwortlich ist.

void PlotQX(CGraphic &graphic)
{
   int points = 1000;
   double q[], x[], r[];
   ArrayResize(q, points);
   ArrayResize(x, points);
   ArrayResize(r, points);   
   
   // Generate data points
   for(int i = 0; i < points; i++)
   {
      q[i] = -2*M_PI + (4*M_PI)*i/(points-1);
      r[i] = MathSin(n * q[i] / (2*d));
      x[i] = r[i] * MathCos(q[i]);
   }
  
   // Get the curve object and set line properties
   CCurve* curve = graphic.CurveAdd(q, x, CURVE_LINES, "q vs x");
   if(curve != NULL)
   {
      curve.LinesStyle(STYLE_SOLID);
      curve.LinesWidth(3);
      curve.Color(ColorToARGB(clrRed, 255));
   }   
   graphic.CurvePlotAll();
}

Innerhalb der Funktion werden Arrays erstellt, um die berechneten Werte von q und x zu speichern. Unter Verwendung der mathematischen Formulierung der Blumenkurve iteriert die Funktion durch eine Reihe von gleichmäßig verteilten Werten q, berechnet den entsprechenden Radienterm und leitet die X-Komponente ab.

Aufzeichnung der Y-Komponente: Die Funktionen SetupChartQY und PlotQY

So wie die X-Komponente der Rosenkurve durch spezielle Einrichtungs- und Plotfunktionen gehandhabt wird, wird die Y-Komponente durch zwei parallele Funktionen verwaltet: SetupChartQY und PlotQY. Diese Funktionen spiegeln die Struktur und den Zweck der entsprechenden X-Komponenten wider und sorgen für Konsistenz und Klarheit in allen visuellen Darstellungen.

Die Funktion SetupChartQY bereitet die Chartumgebung speziell für das Plotten der Y-Komponente vor. Sie konfiguriert die Hintergrundfarbe, die Achsenbereiche, die Achsenbeschriftungen, das Aussehen des Gitters und die Schriftgrößen. Auf diese Weise wird ein sauberer und gut organisierter visueller Raum geschaffen, der auf die Daten der Y-Achse zugeschnitten ist.

Die Funktion PlotQY übernimmt dann die Berechnung und das Rendering der Y-Komponente. 

Die berechneten Werte von q und y werden in das vorbereitete Chart eingezeichnet, wobei die Linieneigenschaften so eingestellt werden, dass die Kurve ein klares und lesbares Aussehen erhält. Nach der Darstellung aktualisiert die Funktion das Grafikobjekt, damit die neu gezeichnete Kurve im Chart sichtbar wird.

Zur Visualisierung der kartesischen Komponenten der Rosenkurve werden für die X-Komponente und die Y-Komponente separate grafische Objekte erstellt, die jeweils über ein eigenes Darstellungsfenster verfügen. Damit ist sichergestellt, dass beide Aspekte der Kurve unabhängig voneinander und übersichtlich dargestellt werden können.

   // Create first graphic object for q vs x
   CGraphic graphic_x;
   
   // Create graphic window for q vs x
   if(!graphic_x.Create(0, g_name + "_q_vs_x", 0, 30, 30, 800, 600))
   {
      Print("Error creating graphic for q vs x!");
      return;
   }

   // Create second graphic object for q vs y
   CGraphic graphic_y;
   
   // Create graphic window for q vs y
   if(!graphic_y.Create(0, g_name + "_q_vs_y", 0, 750, 30, 1500, 600))
   {
      Print("Error creating graphic for q vs y!");
      return;
   }

Für die X-Komponente wird ein grafisches Objekt namens graphic_x instanziiert. Das entsprechende Grafikfenster wird auf dem Chart mit definierten Koordinaten, Breite und Höhe positioniert und bietet einen eigenen Bereich für die Darstellung von q gegen x. Wenn die Erstellung des Fensters fehlschlägt, wird eine Fehlermeldung ausgegeben und die Funktion wird ordnungsgemäß beendet.

In ähnlicher Weise wird für die Y-Komponente ein zweites grafisches Objekt namens graphic_y erstellt. Das Fenster wird separat auf dem Chart positioniert, wobei die Abmessungen so eingestellt sind, dass die Darstellung q gegen y angepasst werden kann. Durch diese Trennung können beide Komponenten zum besseren visuellen Vergleich nebeneinander oder übereinander angeordnet werden.

Der Indikator: Entwicklung des Flower Volatility Index

Nachdem die mathematische Grundlage der Rosenkurve geschaffen wurde, können wir nun von der Theorie zur Anwendung übergehen. Der nächste Schritt besteht darin, die Rosenkurve in einen volatilitätssensitiven Marktoszillator umzuwandeln, den wir Flower Volatility Index (FVI) nennen.

Um dies zu erreichen, ersetzen wir die traditionelle Winkelvariable θ in der Rosenkurve durch eine vom Markt abgeleitete Variable q. Diese Transformation verbindet die geometrischen Eigenschaften der Rosenkurve direkt mit dem Preisverhalten.

Wir definieren den Winkel neu als q, wobei: 

Schauen wir uns die Bestandteile dieser kritischen Substitution an:

• Schlusskurs – MA (gleitender Durchschnitt): Dieser Begriff steht für die Abweichung des Kurses von seinem jüngsten Mittelwert. Es kann ein einfacher oder exponentieller gleitender Durchschnitt verwendet werden, wobei die Periodenlänge die Empfindlichkeit der Strategie bestimmt. Er misst die Dynamik oder Trendrichtung des Vermögenswerts. Größere Abweichungen ergeben größere q-Werte.
• ATR (Average True Range): Durch die Division durch die ATR wird die Abweichung standardisiert, wodurch ein Maß ohne Einheit entsteht. Dieser entscheidende Schritt trägt der Marktvolatilität Rechnung und stellt sicher, dass sich der Indikator an veränderte Marktbedingungen anpasst. Eine große Kursbewegung in einem Umfeld mit geringer Volatilität hat größere Auswirkungen als die gleiche Bewegung in einem Umfeld mit hoher Volatilität.
• Skalar k: Dies ist ein Abstimmungskoeffizient, mit dem der Händler die Empfindlichkeit des q-Oszillators steuern kann. Ein höherer k-Wert verstärkt die Abweichungen und macht den FVI reaktionsfreudiger.

Indem q in die Rosenkurve eingesetzt wird, reagiert der Indikator sowohl auf die Trendverschiebung als auch auf die Volatilitätsbedingungen und erzeugt glattere und besser interpretierbare Schwingungssignale.

Vollständige Indikatorformel

Setzt man das vom Markt abgeleitete q in die Definitionen der Rosenkurve ein, ergibt sich der vollständige Flower Volatility Index:

X-Komponente FVI:

Y-Komponente FVI:

Obwohl beide Oszillatoren innerhalb des Bereichs [-1,+1] begrenzt bleiben und unter allen Marktbedingungen normalisierte und stabile Signale erzeugen, ergibt sich eine wichtige Nuance, wenn man verschiedene Parameterkombinationen von n und d untersucht. Wie in den Abbildungen 4 bis 8 dargestellt, führen bestimmte Konfigurationen dazu, dass entweder die x-Komponente oder die y-Komponente des Flower Volatility Index asymmetrisch wird. In diesen Fällen kann der Oszillator mehr Zeit im positiven als im negativen Bereich verbringen (oder umgekehrt), was zu einer strukturellen Verzerrung der Wellenform führt.

Diese Asymmetrie ergibt sich aus den geometrischen Eigenschaften der Rosenkurve und wird noch deutlicher, wenn n/d unvollständige Blütenblätter oder eine ungleichmäßige Rotationssymmetrie erzeugt. Wenn solche Parameterkombinationen mit der vom Markt abgeleiteten Variable q gepaart werden, kann der resultierende Oszillator in eine Richtung verzerrt werden und eine Seite der Nulllinie über längere Zeiträume bevorzugen.

Diese Eigenschaft ist kein Makel, sondern bietet eine große Chance: Ein natürlich voreingenommener Oszillator kann helfen, dominante langfristige Trends oder anhaltende einseitige Marktphasen zu erkennen. Aus diesem Grund erlaubt der Indikator dem Nutzer, entweder die X- oder die Y-Komponente auszuwählen, was es dem Händler ermöglicht, diese Asymmetrie je nach Ziel seiner Strategie bewusst auszunutzen. 

Demonstration des FVI-Indikators

Untersuchen wir an dieser Stelle, wie sich der Flower Volatility Index in der Praxis verhält.

Der FVI reagiert in hohem Maße auf seine Eingangsparameter, und die Änderung eines dieser Werte – sei es die MA-Periode, die ATR-Periode, die Empfindlichkeitskonstante k oder die Wahl zwischen X- und Y-Komponenten – beeinflusst direkt die Form und Reaktionsfähigkeit des Oszillators. Dank dieser Flexibilität können Händler den Indikator an den Rhythmus des jeweiligen Marktes oder Instruments anpassen, mit dem sie handeln.

Der wahre strategische Vorteil des FVI liegt in seiner abstimmbaren Komplexität. Durch sorgfältige Anpassung der Rosenkurven-Parameter n, d und des Skalierungsparameters k kann der Händler einen Oszillator entwerfen, der sich auf bemerkenswert unterschiedliche Weise verhält:

• Identifizierung von Trends: Anhaltende FVI-Werte über Null können als Aufwärtsmomentum interpretiert werden, während Werte unter Null auf ein Abwärtsmomentum hindeuten.

• Signalerzeugung: Das Kreuzen der FVI-Linie über oder unter ihrer Nulllinie bzw. die Oszillation zwischen ihren Extremen kann Kauf- und Verkaufssignale für ein Trendfolgesystem erzeugen.

• Volatilitätsadaptiv: Die Einbeziehung der ATR macht den FVI zu einem dynamischen Indikator. In Zeiten hoher Volatilität wird er weniger empfindlich und verhindert so das problematische Auf und Nieder. In Zeiten geringer Volatilität ist sie empfindlicher und ermöglicht einen früheren Einstieg in neue Trends.

Abbildung 9: FVI-Indikator 

Bei all diesen Veränderungen bleibt der FVI durch seine Abhängigkeit von der ATR vollständig volatilitätsnormiert. Dadurch wird sichergestellt, dass sich der Oszillator automatisch an veränderte Marktbedingungen anpasst – er expandiert in ruhigen Märkten und komprimiert in volatilen Märkten – und gleichzeitig eine konsistente Interpretierbarkeit über Anlageklassen und Zeitrahmen hinweg gewährleistet.

Der Expertenratgeber: FVI Trendfolge-Strategie

Dieser Expert Advisor verwendet den FVI zur Signalgenerierung und den Awesome Oscillator (AO) als Trendfilter. Handelsgeschäfte werden nur dann ausgeführt, wenn das volatilitätsgetriebene Momentum (FVI) mit dem vorherrschenden Trend (AO) übereinstimmt.

Der Entscheidungsprozess der EA unterliegt den folgenden konkreten Regeln:

1. Bedingungen für einen Verkauf: 

Verkauft wird, wenn:

• AO < 0 (Abwärtstrend), und
• FVI kreuzt über +0,7 (starke Erschöpfung nach oben innerhalb eines Abwärtstrends)

2. Bedingungen für einen Kauf:

Gekauft wird, wenn:

• AO > 0 (Aufwärtstrend), und
• Der FVI kreuzt unter -0,7 (starke Abwärtserschöpfung innerhalb eines Aufwärtstrends)

3. Bedingung für den Ausstieg:

• Handelsgeschäfte werden mit Take Profit und Stop Loss geschlossen.

4. Regel für Mehrfacheröffnungen:

• Einzelne Position pro Seite: Der EA wird nur eine Position für eine bestimmte Handelsrichtung eröffnen. Wenn zum Beispiel eine Kaufposition bereits geöffnet ist, wird keine weitere Kaufposition eröffnet, bis die erste geschlossen ist. Sie kann jedoch eine Verkaufsposition eröffnen, wenn ihre Bedingungen erfüllt sind, sodass die Strategie Trendumkehrungen erfassen kann.
• Abklingzeit für die Eröffnung: Um exzessiven Handel und „Echo“-Signale zu vermeiden, wird der EA eine Abkühlungsphase einführen. Nachdem ein Eröffnungssignal ausgeführt wurde, wartet der EA eine bestimmte Anzahl von Balken (z. B. 10 Balken), bevor er nach einem neuen Eröffnungssignal für eine der beiden Richtungen sucht und darauf reagiert. Dadurch wird die Handelsfrequenz gesteuert und sichergestellt, dass die Signale Zeit haben, sich zu entwickeln.

Verstehen der Code-Struktur des FVI-Expertenberaters

Das Herzstück des FV Expert Advisor (EA) ist die Funktion CalculateFVI(), die für die Berechnung der in der Handelslogik verwendeten FVI-Werte verantwortlich ist. Diese Funktion verarbeitet die wichtigsten Input-Parameter, d. h. MA, ATR und die Kurvenparameter n, d und k, umden Indikatorausgang zu generieren.

void CalculateFVI()
{
    prevFVI = curFVI;

    // Get indicator values
    double ma[1], atr[1], ao[1];
    double close = iClose(_Symbol, _Period, 1);
    
    // Copy indicator values
    if(CopyBuffer(maHandle, 0, 1, 1, ma) < 1 || 
       CopyBuffer(atrHandle, 0, 1, 1, atr) < 1)
    {
        Print("Error copying indicator buffers");
        return;
    }

    // Calculate q
    double q = k * (close - ma[0]) / (atr[0] > 0 ? atr[0] : 1);

    // Calculate r(q)
    double r = MathSin(n * q / (2 * d));

    // Calculate FVI based on selected component
    if(Use_X_Component)
        curFVI = r * MathCos(q); // X component
    else
        curFVI = r * MathSin(q); // Y component
}

Die Berechnung beginnt mit der Speicherung des vorherigen FVI-Werts, sodass der EA bei der Bewertung der Handelsbedingungen frühere und aktuelle Werte vergleichen kann. Anschließend wird der letzte Schlusskurs abgerufen und die MA- und ATR-Werte aus den jeweiligen Indikatorpuffern kopiert. Eine ordnungsgemäße Fehlerbehandlung stellt sicher, dass der EA ordnungsgemäß beendet wird, wenn auf die Indikatordaten nicht zugegriffen werden kann.

Die Funktion CheckForEntry() dient als Entscheidungsmotor des FVI EA. Seine Hauptaufgabe besteht darin, sicherzustellen, dass alle Eingangsbedingungen erfüllt sind, bevor ein Handel ausgeführt wird, um so für Disziplin zu sorgen und eine verfrühte oder ungültige Auftragserteilung zu verhindern.

Die Funktion beginnt mit der Überprüfung, ob seit dem letzten Handel eine ausreichende Anzahl von Balken vergangen ist. Dieser Abstandsmechanismus trägt dazu bei, schnelle, aufeinanderfolgende Einstiege zu vermeiden, insbesondere bei volatilen Marktbedingungen. Sobald die Mindestanforderung erfüllt ist, wertet die Funktion die vordefinierten FVI-basierten Einstiegsregeln aus – ob der aktuelle und der vorherige FVI-Wert die Kriterien für Auf- oder Abwärtskonstellation erfüllen.

void CheckForEntry()
{
    // Check minimum bars between entries
    if(barsSinceLastTrade < MinBarsBtwEntries)
        return;

    // Get Awesome Oscillator value
    double ao[1];
    if(CopyBuffer(aoHandle, 0, 1, 1, ao) < 1)
    {
        Print("Error copying AO buffer");
        return;
    }

    // Check for buy conditions
    if(ao[0] > 0 && prevFVI > -0.7 && curFVI < -0.7)
    {
        if(CountPositions(POSITION_TYPE_BUY) == 0)
        {
            OpenBuyOrder();
            barsSinceLastTrade = 0;
        }
    }

    // Check for sell conditions
    if(ao[0] < 0 && prevFVI < 0.7 && curFVI > 0.7)
    {
        if(CountPositions(POSITION_TYPE_SELL) == 0)
        {
            OpenSellOrder();
            barsSinceLastTrade = 0;
        }
    }
}

Wenn ein gültiges Kaufsignal erkannt wird, löst der EA die Funktion OpenBuyOrder() aus, um eine Kaufauftrag an das Terminal des Brokers zu übermitteln. Wenn ein Verkaufssignal bestätigt wird, wird die Funktion OpenSellOrder() ausgeführt, um eine Verkaufsposition zu eröffnen.

Nachdem ein Handel erfolgreich platziert wurde, wird der Zähler barsSinceLastTrade auf Null zurückgesetzt, um sicherzustellen, dass der EA erneut die erforderlichen Abstände einhält, bevor er den nächsten Handel einleitet.

Durch diese Struktur bietet die Funktion CheckForEntry() einen zuverlässigen und effizienten Rahmen für die Verwaltung der Handelsausführung und stellt sicher, dass Positionen nur unter genau definierten und kontrollierten Bedingungen eröffnet werden.

FVI EA-Demonstration

Der Expert Advisor enthält einen umfassenden Satz von Eingabeparametern, die sowohl die Handelseinstellungen als auch die FVI-Parameter abdecken und dem Händler eine Feinabstimmung der Performance ermöglichen. Diese Eingaben sind für die Optimierung vollständig zugänglich, sodass die Nutzer Variablen wie Risikoeinstellungen, Empfindlichkeitsparameter und FVI-Berechnungswerte anpassen können. Wie in Abbildung 10 dargestellt, bietet die Optimierungsschnittstelle eine strukturierte Möglichkeit, mit verschiedenen Parameterkombinationen zu experimentieren, und hilft Händlern, die effektivste Konfiguration für verschiedene Marktbedingungen zu ermitteln.

Abbildung 10: EA-Eingabewerte

Abbildung 11 zeigt, wie der Expert Advisor auf der Grundlage der definierten Handelslogik Handelsgeschäfte ausführt. Sobald die Marktbedingungen mit den festgelegten Einstiegsregeln übereinstimmen, löst der EA automatisch Kauf- oder Verkaufspositionen aus und verwaltet jede Ausführung gemäß den konfigurierten Risikoparametern und FVI-basierten Signalen. Diese visuelle Darstellung hilft, den Fluss von der Signalerzeugung bis zur Orderplatzierung zu veranschaulichen und zeigt die Fähigkeit des EA, systematisch auf Marktbewegungen zu reagieren.

Abbildung 11: FVI EA-Demonstration

Schlussfolgerung

In diesem Artikel wird der Flower Volatility Index (FVI) vorgestellt, ein neuartiger Ansatz, der die mathematische Eleganz der Rosenkurven in ein funktionales Handelsinstrument verwandelt. Durch die Abbildung der Marktvolatilität und der Preisverschiebung durch die X- und Y-Komponenten der Blumenkurve haben wir gezeigt, wie der FVI verwendet werden kann, um Tendenzen, Trendstärke und potenzielle Wendepunkte zu erkennen.

In dem Artikel wurde auch die gesamte Struktur des FVI Expert Advisors beschrieben – von der Kurvenerstellung und grafischen Darstellung bis hin zur Signalgenerierung und automatischen Handelsausführung. Mit dieser Arbeit haben wir gezeigt, wie mathematische Modelle in praktische Handelsmechanismen umgewandelt werden können, die sowohl die Analyse als auch die Entscheidungsfindung unter realen Marktbedingungen unterstützen.

Insgesamt unterstreicht die Studie das Potenzial geometrischer und trigonometrischer Funktionen als alternative Rahmen für das Verständnis des Marktverhaltens.

In unserer nächsten Arbeit werden wir die Strategie allein und mit anderen Indikatoren testen, um die geeigneten Paare für verschiedene Finanzinstrumente zu finden. Bis dahin: Viel Spaß beim Handeln.

Dateien	Beschreibung
PetalCurve.mq5	Diese Skriptdatei stellt die Rosenkurven dar. Das Chart kann entfernt werden, wenn die Vorlage aktualisiert oder ersetzt wird.
PetalWaves.mq5	Die Skriptdatei stellt die X- und Y-Komponenten der Kurven als Wellenmuster dar. Aktualisiert die Vorlage, um die gezeichneten Objekte zu entfernen.
FlowerVolatilityIndex.mq5	Diese Indikatordatei stellt den Flower Volatility Index in einem separaten Fenster dar.
FVI_EA.mq5	Diese Datei enthält den EA, der die Handelsgeschäfte automatisch ausführt.