Entwicklung eines Toolkit zur Analyse von Preisaktionen (Teil 15): Einführung in die Quarters-Theorie (I) - Quarters Drawer Script

Inhalt

• Einführung
• Konzept Übersicht
• MQL5-Implementierung
• MQL5 Skript
• Ergebnisse
• Schlussfolgerung

Einführung

Auf jedem Markt bewegen sich die Preise in Zyklen. Unabhängig davon, ob die Preise nach oben oder nach unten tendieren, schwanken sie immer wieder innerhalb bestimmter Bandbreiten. Im Laufe der Zeit haben die Händler viele Theorien entwickelt, um diese Muster zu erklären. In unserer fortlaufenden Serie bauen wir ein umfassendes Toolkit zur Preisaktionsanalyse auf. Heute stellen wir einen innovativen Ansatz vor, den wir mit MQL5 automatisiert haben, um die Anwendung zu vereinfachen und beeindruckende Ergebnisse zu erzielen.

Im Mittelpunkt dieses Artikels steht die Quarters Theory. Es wurde von Ilian Yotov entwickelt, ein Name, der Tausenden von Devisenhändlern und Forex-Strategen durch seine Arbeit im Traders Television Network bekannt ist. Ilian gründete AllThingsForex.com und TraderTape.com und moderiert die beliebte tägliche Show All Things Forex. Seine Theorie besagt, dass bedeutende Kursbewegungen zwischen zwei großen Viertelpunkten stattfinden und in Schritten von 250 PIPs verlaufen. Diese Methode bietet klare Anhaltspunkte zur Identifizierung von wichtigen Unterstützungs- und Widerstandsniveaus und vermittelt Händlern praktische Erkenntnisse.

Dieser Artikel ist der erste Teil unserer Quarter-Theorie. In dieser Folge konzentrieren wir uns auf die Konstruktion der Viertel (quarter) mit Hilfe unseres Skripts „quarters drawer“. Durch das automatische Einzeichnen dieser entscheidenden Niveaus bieten wir einen praktischen Ausgangspunkt für die Visualisierung von wichtigen Umkehr- und Fortsetzungszonen. Im Zuge der Weiterentwicklung dieser Theorie werden wir noch robustere Instrumente zur Unterstützung der Signalgenerierung und der fortgeschrittenen Marktanalyse entwickeln.

Konzept Übersicht

Die Quarters-Theorie ist ein Ansatz der technischen Analyse, der eine bedeutende Preisspanne in kleinere, aussagekräftigere Segmente unterteilt. In diesem Rahmen definiert ein „MajorStep“ - z. B. 0,1000 bei Währungspaaren wie EUR/USD - die Differenz zwischen großen ganzen Zahlen (z. B. 1,2000 bis 1,3000). Dieser Bereich wird dann in vier gleiche Teile unterteilt, die als große Viertel bezeichnet werden. Jedes große Viertel stellt einen kritischen Punkt dar, an dem der Kurs pausieren, umkehren oder sich beschleunigen kann, und bietet Händlern potenzielle Unterstützungs- und Widerstandsbereiche.

Zu den wichtigsten Komponenten der Quarters-Theorie gehören

• Große, ganze Zahlen: Dies sind die primären Niveaus (z. B. 1,2000, 1,3000), die die Handelsspanne einrahmen. Sie dienen als Bezugspunkte, um die feinere Struktur der Theorie aufzubauen.
• Linien der großen Viertel: Das Intervall zwischen zwei Hauptstufen ist gleichmäßig in vier Abschnitte unterteilt. Diese Linien zeigen die Zwischenstufen an, die oft eine wichtige Rolle im Preisverhalten spielen. Händler nutzen diese Niveaus, um potenzielle Wendepunkte oder Bereiche der Konsolidierung zu antizipieren.
• Linien der kleinen Viertel (optional): Um die Genauigkeit zu erhöhen, kann jedes 100-Punkte-Segment in noch kleinere Intervalle, kleine Viertel, unterteilt werden. Obwohl diese Linien zusätzliche Details bieten, liegt das Hauptaugenmerk weiterhin auf den großen Quartalsebenen.
• Überschreitungs-/Unterschreitungsgebiete: Um jede große Viertellinie herum werden leichte Abweichungen (Über- und Unterschreitungen) eingezeichnet, um Zonen zu signalisieren, in denen der Preis vorübergehend über oder unter dem erwarteten Niveau liegen könnte. Diese Bereiche helfen dabei, mögliche Korrekturen oder Umkehrungen zu erkennen.

Weitere Informationen finden Sie in den folgenden Charts

Abb. 1. Die Viertel (Quarters)

Abb. 2. Die Viertel (Quarters)

Durch die visuelle Markierung dieser Schlüsselebenen auf einem Chart bietet die Quartals-Theorie Händlern eine strukturierte Methode zur Bewertung der Preisdynamik. Dieser Ansatz wird im Skript „Quarters Drawer“ umgesetzt, das verschiedene Linien mit unterschiedlichen Stilen und Farben zeichnet, um die Übersichtlichkeit zu erhöhen und sicherzustellen, dass jede Gruppe (Haupt-, große Viertel- und kleine Viertel-Linien) leicht zu unterscheiden ist. Dieses visuelle Instrument untermauert die Theorie, indem es die entscheidenden Preissegmente deutlich hervorhebt.

MQL5-Implementierung

Der erste Block des Skripts enthält einen Header-Kommentar, der wichtige Details wie den Namen des Skripts, die Version, Copyright-Informationen und einen Link zum Profil des Autors enthält. Anschließend werden in Eigenschaftserklärungen wichtige Metadaten (wie Copyright und Version) eingebettet und strenge Kompilierungseinstellungen durchgesetzt. Diese Kombination schafft die Identität des Skripts und stellt sicher, dass es robuste Kodierungsstandards einhält.

//+------------------------------------------------------------------+
//|                                              Quarters Drawer.mql5|
//|                                Copyright 2025, Christian Benjamin|
//|                           https://www.mql5.com/en/users/lynnchris|
//+------------------------------------------------------------------+
#property copyright "Christian Benjamin"
#property link      "https://www.mql5.com/en/users/lynnchris"
#property version   "1.0"
#property strict

Anschließend werden die Eingabeparameter definiert, um dem Nutzer die vollständige Kontrolle über das Verhalten und das Aussehen des Skripts zu geben. Hier legen Sie das Intervall zwischen den wichtigsten Kursniveaus mit einem Parameter wie MajorStep fest und verwenden boolesche Flags, um das Zeichnen von großen Viertellinien, kleinen Viertellinien und Markierungen der Über- und Unterschreitungen umzuschalten. Wenn z. B. DrawLargeQuarters auf true gesetzt ist, zeichnet das Skript große Viertellinien, aber wenn es auf false gesetzt ist, werden sie nicht angezeigt.

Dasselbe gilt für DrawSmallQuarters und DrawOvershootAreas: Wenn Sie keine kleinen Viertellinien oder Überschreitungsbereiche sehen möchten, setzen Sie die Werte einfach auf false. Dadurch lässt sich die Anzeige leicht anpassen, ohne dass die Kernlogik verändert werden muss. Darüber hinaus stehen für jeden Linientyp Farbeinstellungen und Optionen für Linienstil und -dicke zur Verfügung, sodass Händler die visuelle Ausgabe leicht an ihre persönlichen Vorlieben und Handelsstrategien anpassen können.

//---- Input parameters -------------------------------------------------
input double MajorStep          = 0.1000;   // Difference between major whole numbers.
input bool   DrawLargeQuarters  = true;     // Draw intermediate large quarter lines.
input bool   DrawSmallQuarters  = true;     // Draw small quarter lines.
input bool   DrawOvershootAreas = true;     // Mark overshoot/undershoot areas for large quarter lines.

//---- Color settings ---------------------------------------------------
input color  MajorColor         = 0x2F4F4F; // Dark Slate Gray for major lines.
input color  LargeQuarterColor  = 0x8B0000; // Dark Red for large quarter lines.
input color  SmallQuarterColor  = 0x00008B; // Dark Blue for small quarter lines.
input color  OvershootColor     = clrRed;   // Red for overshoot/undershoot lines.

//---- Group style and thickness settings -------------------------------
input ENUM_LINE_STYLE MajorLineStyle       = STYLE_SOLID;
input int    MajorLineWidth                 = 4;
input ENUM_LINE_STYLE LargeQuarterLineStyle  = STYLE_DOT;
input int    LargeQuarterLineWidth          = 3;
input ENUM_LINE_STYLE OvershootLineStyle     = STYLE_DASH;
input int    OvershootLineWidth             = 1;
input ENUM_LINE_STYLE SmallQuarterLineStyle  = STYLE_SOLID;
input int    SmallQuarterLineWidth          = 1;

Wenn Sie im Skript hexadezimale Farbcodes sehen, stellen sie bestimmte Farben durch die Kombination von Rot-, Grün- und Blauwerten dar. Zum Beispiel:

• 0x2F4F4F - Dieser Code entspricht Dark Slate Gray. Die zweistelligen Paare stehen jeweils für die Rot-, Grün- und Blaukomponente. Hier steht „2F“ (47 in Dezimalzahlen) für Rot und „4F“ (79 in Dezimalzahlen) sowohl für Grün als auch für Blau, wodurch ein gedämpfter, kühler Grauton entsteht, der sich ideal für Primärlinien in einem Chart eignet.
• 0x8B0000 - Dieser Code steht für Dunkelrot. Bei diesem Wert ist „8B“ (139 in Dezimalzahlen) eine starke Rotkomponente, während sowohl die Grün- als auch die Blaukomponente „00“ (Null) sind, was zu einem tiefen, intensiven Rot führt. Diese Farbe wird in der Schrift verwendet, um große Viertellinien zu betonen.
• 0x00008B - Dieser Code steht für Dunkelblau. In diesem Fall sind die Rot- und Grünkomponenten „00“ und die Blaukomponente ist „8B“ (139 in Dezimalzahlen), was eine tiefblaue Farbe ergibt. Diese wird auf kleinen Viertellinien angebracht, die einen deutlichen visuellen Kontrast bilden.

Zusätzlich zu diesen fest kodierten hexadezimalen Werten verwendet das Skript auch eine vordefinierte Konstante namens clrRed. Anstatt einen Hex-Code manuell einzugeben, können Sie einfach diese integrierte Konstante verwenden, die normalerweise die Farbe Rot mit den RGB-Werten (255, 0, 0) darstellt. Das Skript legt beispielsweise die Farbe der Überschreitungen wie folgt fest:

input color OvershootColor = clrRed;

Nach den Eingaben enthält das Skript eine spezielle Funktion, die das Zeichnen von horizontalen Linien im Chart übernimmt. Diese Funktion prüft zunächst, ob eine Linie mit dem angegebenen Namen bereits existiert und entfernt sie gegebenenfalls, um Duplikate zu vermeiden. Anschließend wird eine neue horizontale Linie auf einem bestimmten Preisniveau erstellt und die definierte Farbe, der Stil und die Breite angewendet. Diese modulare Funktion sorgt dafür, dass sich jede Linie über das gesamte Chart erstreckt, und vereinfacht so das Zeichnen mehrerer Linien im gesamten Skript.

//+------------------------------------------------------------------+
//| DrawHorizontalLine: Creates or replaces a horizontal line        |
//+------------------------------------------------------------------+
void DrawHorizontalLine(string name, double price, color lineColor, int width, ENUM_LINE_STYLE style)
{
   // Delete the object if it already exists
   if(ObjectFind(0, name) != -1)
      ObjectDelete(0, name);

   // Create a new horizontal line object
   if(!ObjectCreate(0, name, OBJ_HLINE, 0, 0, price))
   {
      Print("Failed to create line: ", name);
      return;
   }

   // Set properties: color, style, width, and extension to the right
   ObjectSetInteger(0, name, OBJPROP_COLOR, lineColor);
   ObjectSetInteger(0, name, OBJPROP_STYLE, style);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, width);
   ObjectSetInteger(0, name, OBJPROP_RAY_RIGHT, true);
}

Die Hauptausführung des Skripts beginnt mit der Funktion OnStart, in der das aktuelle Symbol und sein Geldkurs abgefragt werden. Dieser Schritt ist entscheidend, da alle nachfolgenden Berechnungen von einem gültigen Marktpreis abhängen. Wenn der Geldkurs nicht verfügbar ist, wird das Skript vorzeitig beendet, um Fehler zu vermeiden und sicherzustellen, dass weitere Operationen nur mit gültigen Daten durchgeführt werden.

void OnStart()
{
   // Get current symbol price
   string symbol = _Symbol;
   double currentPrice = SymbolInfoDouble(symbol, SYMBOL_BID);
   if(currentPrice == 0)
      return;

Sobald der aktuelle Preis ermittelt ist, berechnet das Skript die wichtigsten Preisniveaus, die als primäre Bezugspunkte dienen werden. Die untere Stufe wird durch Abrunden des aktuellen Preises auf das nächste durch MajorStep definierte Intervall bestimmt, und die obere Stufe wird durch Hinzufügen desselben Schritts berechnet. Diese berechneten Ebenen schaffen einen strukturierten Rahmen, der klare Grenzen für den Rest des visuellen Rasters setzt.

   // Calculate the major range based on the current price and MajorStep
   double lowerMajor = MathFloor(currentPrice / MajorStep) * MajorStep;
   double upperMajor = lowerMajor + MajorStep;

Anhand dieser wichtigen Kursniveaus zeichnet das Skript dann zwei markante horizontale Linien an der unteren und oberen Grenze. Diese Hauptlinien sind mit bestimmten Farben, Dicken und Linienmustern gestaltet, sodass sie auf dem Chart leicht zu erkennen sind. Sie bilden das Rückgrat der visuellen Struktur des Charts und helfen Händlern, wichtige Unterstützungs- und Widerstandsbereiche schnell zu erkennen.

   // Draw Major Whole Number lines at lower and upper boundaries
   DrawHorizontalLine("MajorLower", lowerMajor, MajorColor, MajorLineWidth, MajorLineStyle);
   DrawHorizontalLine("MajorUpper", upperMajor, MajorColor, MajorLineWidth, MajorLineStyle);

Wenn die Option zum Zeichnen großer Viertellinien aktiviert ist, unterteilt das Skript das Hauptintervall in vier gleiche Teile. Es berechnet die Zwischenstufen zwischen den Hauptgrenzen und zeichnet an diesen Punkten horizontale Linien. Wenn außerdem die Über- und Unterschreitungsmarkierungen aktiviert sind, werden zusätzliche Linien direkt über und unter jeder großen Viertellinie gezeichnet. Diese zusätzlichen Marker dienen dazu, Bereiche hervorzuheben, in denen der Kurs vorübergehend über seine erwartete Spanne hinausgehen könnte, und bieten Händlern wertvolle Einblicke in potenzielle Kursumkehrungen.

   // Draw Large Quarter lines and overshoot/undershoot lines if enabled
   if(DrawLargeQuarters)
   {
      double LQIncrement = MajorStep / 4.0;
      for(int i = 1; i < 4; i++)
      {
         double level = lowerMajor + i * LQIncrement;
         string objName = "LargeQuarter_" + IntegerToString(i);
         DrawHorizontalLine(objName, level, LargeQuarterColor, LargeQuarterLineWidth, LargeQuarterLineStyle);

         if(DrawOvershootAreas)
         {
            double smallQuarter = MajorStep / 40.0;
            DrawHorizontalLine("Overshoot_" + IntegerToString(i) + "_up", level + smallQuarter, OvershootColor, OvershootLineWidth, OvershootLineStyle);
            DrawHorizontalLine("Undershoot_" + IntegerToString(i) + "_down", level - smallQuarter, OvershootColor, OvershootLineWidth, OvershootLineStyle);
         }
      }
   }

Für noch feinere Details kann das Skript auch die Linien der kleine Viertel zeichnen, wenn diese Option aktiviert ist. Es unterteilt das Hauptintervall in zehn Segmente und teilt jedes Segment weiter in kleinere Unterabschnitte auf. Auf diese Weise entsteht ein differenzierteres Raster, das subtile Kursbewegungen erfasst und Händlern eine detaillierte Ansicht bietet, die besonders nützlich sein kann, um präzise Ein- und Ausstiegspunkte zu identifizieren.

   // Draw Small Quarter lines if enabled
   if(DrawSmallQuarters)
   {
      double segStep = MajorStep / 10.0;
      double smallQuarter = segStep / 4.0;
      for(int seg = 0; seg < 10; seg++)
      {
         double segStart = lowerMajor + seg * segStep;
         for(int j = 1; j < 4; j++)
         {
            double level = segStart + j * smallQuarter;
            string objName = "SmallQuarter_" + IntegerToString(seg) + "_" + IntegerToString(j);
            DrawHorizontalLine(objName, level, SmallQuarterColor, SmallQuarterLineWidth, SmallQuarterLineStyle);
         }
      }
   }

Um die visuellen Verbesserungen abzurunden, fügt das Skript dem Chart eine dauerhafte Kennzeichnung oder ein Logo hinzu. Dieses Kennzeichnung zeigt den Namen des Skripts, die Version und Informationen zum Autor an und dient sowohl als Anerkennung als auch als Schnellreferenz für die Nutzer. Bevor die Kennzeichnung platziert wird, prüft das Skript, ob bereits eine Instanz vorhanden ist, um Duplikate zu vermeiden, und positioniert die Kennzeichnung dann in der oberen rechten Ecke mit sorgfältig gewählten Schriftgrößen- und Farbeinstellungen für eine gute Sichtbarkeit.

   // Create a persistent label (logo) in the top-right corner
   if(ObjectFind(0, "ScriptLogo") != -1)
      ObjectDelete(0, "ScriptLogo");
   if(ObjectCreate(0, "ScriptLogo", OBJ_LABEL, 0, 0, 0))
   {
      string logoText = "Script: DrawQuarters_DarkBold\nv1.04\nby Christian Benjamin";
      ObjectSetString(0, "ScriptLogo", OBJPROP_TEXT, logoText);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_COLOR, clrYellow);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_FONTSIZE, 14);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_CORNER, CORNER_RIGHT_UPPER);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_XDISTANCE, 80);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_YDISTANCE, 10);
   }

Abschließend aktualisiert das Skript das Chart mit einem Redraw-Befehl, sodass alle gezeichneten Objekte (Linien und Beschriftungen) sofort sichtbar sind. Dieser letzte Schritt ist von entscheidender Bedeutung, da er die Anzeige mit den neuesten Marktdaten und nutzerdefinierten Einstellungen aktualisiert und so ein vollständiges und aktuelles visuelles Tool für die technische Analyse bietet.

   // Redraw the chart to display all objects
   ChartRedraw();
}

MQL5 Code

//+------------------------------------------------------------------+
//|                                              Quarters Drawer.mql5|
//|                                Copyright 2025, Christian Benjamin|
//|                           https://www.mql5.com/en/users/lynnchris|
//+------------------------------------------------------------------+
#property copyright "Christian Benjamin"
#property link      "https://www.mql5.com/en/users/lynnchris"
#property version   "1.0"
#property strict

//---- Input parameters -------------------------------------------------
input double MajorStep          = 0.1000;   // Difference between major whole numbers.
input bool   DrawLargeQuarters  = true;     // Draw intermediate large quarter lines.
input bool   DrawSmallQuarters  = true;    // Draw small quarter lines.
input bool   DrawOvershootAreas = true;     // Mark overshoot/undershoot areas for large quarter lines.

//---- Color settings ---------------------------------------------------
input color  MajorColor         = 0x2F4F4F; // Dark Slate Gray for major lines.
input color  LargeQuarterColor  = 0x8B0000; // Dark Red for large quarter lines.
input color  SmallQuarterColor  = 0x00008B; // Dark Blue for small quarter lines.
input color  OvershootColor     = clrRed;   // Red for overshoot/undershoot lines.

//---- Group style and thickness settings -------------------------------
input ENUM_LINE_STYLE MajorLineStyle       = STYLE_SOLID;
input int    MajorLineWidth                 = 4;
input ENUM_LINE_STYLE LargeQuarterLineStyle  = STYLE_DOT;
input int    LargeQuarterLineWidth          = 3;
input ENUM_LINE_STYLE OvershootLineStyle     = STYLE_DASH;
input int    OvershootLineWidth             = 1;
// For small quarter lines, we now use a continuous (solid) style.
input ENUM_LINE_STYLE SmallQuarterLineStyle  = STYLE_SOLID;
input int    SmallQuarterLineWidth          = 1;

//+------------------------------------------------------------------+
//| DrawHorizontalLine: Creates or replaces a horizontal line        |
//+------------------------------------------------------------------+
void DrawHorizontalLine(string name, double price, color lineColor, int width, ENUM_LINE_STYLE style)
  {
   if(ObjectFind(0, name) != -1)
      ObjectDelete(0, name);

   if(!ObjectCreate(0, name, OBJ_HLINE, 0, 0, price))
     {
      Print("Failed to create line: ", name);
      return;
     }

   ObjectSetInteger(0, name, OBJPROP_COLOR, lineColor);
   ObjectSetInteger(0, name, OBJPROP_STYLE, style);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, width);
   ObjectSetInteger(0, name, OBJPROP_RAY_RIGHT, true);
  }

//+------------------------------------------------------------------+
//| Script entry point                                               |
//+------------------------------------------------------------------+
void OnStart()
  {
// Get current symbol price
   string symbol = _Symbol;
   double currentPrice = SymbolInfoDouble(symbol, SYMBOL_BID);
   if(currentPrice == 0)
      return;

// Calculate the major range
   double lowerMajor = MathFloor(currentPrice / MajorStep) * MajorStep;
   double upperMajor = lowerMajor + MajorStep;

// Draw Major Whole Number lines
   DrawHorizontalLine("MajorLower", lowerMajor, MajorColor, MajorLineWidth, MajorLineStyle);
   DrawHorizontalLine("MajorUpper", upperMajor, MajorColor, MajorLineWidth, MajorLineStyle);

// Draw Large Quarter lines and their overshoot/undershoot lines
   if(DrawLargeQuarters)
     {
      double LQIncrement = MajorStep / 4.0;
      for(int i = 1; i < 4; i++)
        {
         double level = lowerMajor + i * LQIncrement;
         string objName = "LargeQuarter_" + IntegerToString(i);
         DrawHorizontalLine(objName, level, LargeQuarterColor, LargeQuarterLineWidth, LargeQuarterLineStyle);

         if(DrawOvershootAreas)
           {
            double smallQuarter = MajorStep / 40.0;
            DrawHorizontalLine("Overshoot_" + IntegerToString(i) + "_up", level + smallQuarter, OvershootColor, OvershootLineWidth, OvershootLineStyle);
            DrawHorizontalLine("Undershoot_" + IntegerToString(i) + "_down", level - smallQuarter, OvershootColor, OvershootLineWidth, OvershootLineStyle);
           }
        }
     }

// Draw Small Quarter lines if enabled (continuous lines, without overshoot/undershoot)
   if(DrawSmallQuarters)
     {
      double segStep = MajorStep / 10.0;
      double smallQuarter = segStep / 4.0;
      for(int seg = 0; seg < 10; seg++)
        {
         double segStart = lowerMajor + seg * segStep;
         for(int j = 1; j < 4; j++)
           {
            double level = segStart + j * smallQuarter;
            string objName = "SmallQuarter_" + IntegerToString(seg) + "_" + IntegerToString(j);
            DrawHorizontalLine(objName, level, SmallQuarterColor, SmallQuarterLineWidth, SmallQuarterLineStyle);
           }
        }
     }

// Create a persistent label (logo) in the top-right corner
   if(ObjectFind(0, "ScriptLogo") != -1)
      ObjectDelete(0, "ScriptLogo");
   if(ObjectCreate(0, "ScriptLogo", OBJ_LABEL, 0, 0, 0))
     {
      string logoText = "Script: DrawQuarters_DarkBold\nv1.04\nby Christian Benjamin";
      ObjectSetString(0, "ScriptLogo", OBJPROP_TEXT, logoText);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_COLOR, clrYellow);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_FONTSIZE, 14);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_CORNER, CORNER_RIGHT_UPPER);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_XDISTANCE, 80);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_YDISTANCE, 10);
     }

   ChartRedraw();
  }
//+------------------------------------------------------------------+

Ergebnisse

Bevor Sie sich mit den Ergebnissen befassen, erfahren Sie hier, wie Sie das Skript erstellen und kompilieren. Öffnen Sie MetaEditor und wählen Sie „Neu“ und dann „Skript“. Geben Sie einen Namen für Ihr Skript ein und beginnen Sie, Ihren Code zu schreiben. Kompilieren Sie das Skript. Falls Fehler auftreten, beheben Sie diese, bis die Kompilierung erfolgreich abgeschlossen ist. Testen Sie Ihr Skript nach der Kompilierung in einem Chart. Da es sich nicht um einen EA handelt, können Sie ihn auf einem Live-Chart im Demo- oder Live-Modus laufen lassen, ohne dass Ihr Kontostand beeinträchtigt wird.

In diesem Abschnitt habe ich mehrere Charte zum visuellen Verständnis. Ich werde Sie Schritt für Schritt durch jedes Chart führen. Das erste Chart zeigt einen Test für das Paar AUD/USD. In diesem Test habe ich DrawLargeQuarters zusammen mit den Über- und Unterschreitungen aktiviert und DrawSmallQuarters auf false gesetzt.

//---- Input parameters -------------------------------------------------
input double MajorStep          = 0.1000;   // Difference between major whole numbers.
input bool   DrawLargeQuarters  = true;     // Draw intermediate large quarter lines.
input bool   DrawSmallQuarters  = false;    // Draw small quarter lines.
input bool   DrawOvershootAreas = true;     // Mark overshoot/undershoot areas for large quarter lines.

Schauen wir uns Abbildung 2 unten an. Es zeigt, wie ich das Skript hinzugefügt und die Ergebnisse aufgezeichnet habe. Wir sehen, wie der Preis mit den Quarters und ihren Über- und Unterschreitungen interagiert.

Abb. 2. AUDUSD Quartale

Nachfolgend sehen Sie einen Screenshot, der mit demselben Paar aufgenommen wurde. Ich habe die Auswirkungen der einzelnen Quartale in der Grafik hervorgehoben. Die Ergebnisse sind eindeutig: Der Markt findet Unterstützung und Widerstand bei unseren größeren Quartalswerten. Ich habe die Überschreitungslinien und die Optionen für die kleineren Viertel auf „false“ gesetzt, um diese großen Quartile deutlich zu visualisieren.

//---- Input parameters -------------------------------------------------
input double MajorStep          = 0.1000;   // Difference between major whole numbers.
input bool   DrawLargeQuarters  = true;     // Draw intermediate large quarter lines.
input bool   DrawSmallQuarters  = false;    // Draw small quarter lines.
input bool   DrawOvershootAreas = false;     // Mark overshoot/undershoot areas for large quarter lines.

Siehe Abbildung 3 unten

Abb. 3. Große Viertel

Ich habe weiter reingezoomt, damit Sie deutlich sehen können, wie der Preis mit der großen Viertellinie interagiert, einschließlich ihrer Unter- und Überschreitungen.

Abb. 4. Unter- und Überschreitungen.

Zum Schluss wollen wir noch die Performance des Skripts auf EUR/USD untersuchen. Die Schlüsselniveaus, die jeder Devisenhändler anstrebt, werden durch die Quartalsniveaus eindeutig identifiziert.

Abb. 5. EURUSD-Viertel

Bitte lesen Sie das Buch: 

Schlussfolgerung

Ich bin sicher, dass Sie alle die Auswirkungen dieses Skripts erkennen können. Es zeichnet die Viertel und führt die Berechnungen durch, die manuell sehr zeitaufwändig wären. Ein bemerkenswerter Aspekt ist die Tatsache, dass die Linien der Viertel als Unterstützungs- und Umkehrniveaus dienen. Die großen Viertel, die großen unteren und oberen Niveaus, fungieren als wichtiger Widerstand und Unterstützung, während die kleineren Viertel als kleinere Niveaus dienen. Dieser erste Ansatz ist eine gute Ausgangsbasis für eine automatisierte Analyse. Wir freuen uns darauf, weitere Instrumente zu entwickeln, wenn wir uns tiefer in diese Theorie vertiefen. Wenn Sie Vorschläge oder Empfehlungen haben, teilen Sie diese bitte mit.

Datum	Name des Werkzeugs	Beschreibung	Version	Aktualisierungen	Hinweis
01/10/24	Chart Projector	Skript zur Überlagerung der Kursentwicklung des Vortages mit Geistereffekt.	1.0	Erste Veröffentlichung	Toolkit Nummer 1
18/11/24	Analytical Comment	Er liefert Informationen zum Vortag in Tabellenform und nimmt die zukünftige Marktentwicklung vorweg.	1.0	Erste Veröffentlichung	Toolkit Nummer 2
27/11/24	Analytics Master	Reguläre Aktualisierung der Marktmetriken alle zwei Stunden.	1.01	Zweite Veröffentlichung	Toolkit Nummer 3
02/12/24	Analytics Forecaster	Reguläre Aktualisierung der Marktmetriken alle zwei Stunden mit Telegram-Integration.	1.1	Dritte Ausführung	Toolkit Nummer 4
09/12/24	Volatility Navigator	Der EA analysiert die Marktbedingungen anhand der Indikatoren Bollinger Bands, RSI und ATR.	1.0	Erste Veröffentlichung	Toolkit Nummer 5
19/12/24	Mean Reversion Signal Reaper	Analysiert den Markt anhand der Strategie „Umkehr zur Mitte“ und liefert Signale.	1.0	Erste Veröffentlichung	Toolkit Nummer 6
9/01/25	Signal-Impuls	Analysator für mehrere Zeitrahmen.	1.0	Erste Veröffentlichung	Toolkit Nummer 7
17/01/25	Metrics Board	Bedienfeld mit Taste für die Analyse.	1.0	Erste Veröffentlichung	Toolkit Nummer 8
21/01/25	External Flow	Analytik durch externe Bibliotheken.	1.0	Erste Veröffentlichung	Toolkit Nummer 9
27/01/25	VWAP	Volumengewichteter Durchschnittspreis	1.3	Erste Veröffentlichung	Toolkit Nummer 10
02/02/25	Heikin Ashi	Trendglättung und Identifizierung von Umkehrsignalen	1.0	Erste Veröffentlichung	Toolkit Nummer 11
04/02/25	FibVWAP	Signalerzeugung durch Python-Analyse	1.0	Erste Veröffentlichung	Toolkit Nummer 12
14/02/25	RSI DIVERGENCE	Kursentwicklung versus RSI-Divergenzen	1.0	Erste Veröffentlichung	Toolkit Nummer 13
17/02/25	Parabolischer Stopp und Umkehr (PSAR)	Automatisierung der PSAR-Strategie	1.0	Erste Veröffentlichung	Toolkit Nummer 14
20/02/25	Quarters Drawer Script	Einzeichnen der Linien der Viertel auf den Chart	1.0	Erste Veröffentlichung	Toolkit Nummer 15