Entwicklung eines Toolkit zur Analyse von Preisaktionen (Teil 3): Analytics Master — EA

Inhalt

• Einführung
• Rückblick auf das vorherige Tool
• Überblick über den Analytic Master
• Erforschung des Expert Advisor Codes
• Code-Aufschlüsselung 
• Code-Implementierung und -Prüfung
• Schlussfolgerung

Einführung

Nachdem ich in der vorangegangenen Folge das Skript für analytische Kommentare entwickelt habe, habe ich seine Einschränkungen in Bezug auf die Skripteigenschaften festgestellt, die ich im Folgenden darlegen werde. Ich erkenne den beträchtlichen Einfluss an, den das analytische Kommentar-Skript in der Handelsgemeinschaft hatte, und habe einen Expert Advisor (EA) namens Analytics Master entwickelt. Dieser EA bietet dieselbe Analyse und liefert darüber hinaus zusätzliche Metriken für bessere Handelseinblicke. Dieses neue Tool bietet mehrere Vorteile, u. a. die Möglichkeit, die Metrik alle zwei Stunden zu aktualisieren, während das Skript nur einmal Metrikinformationen schreiben konnte. Der EA verbessert die Analyse und hält die Nutzer auf dem Laufenden.

In einigen Fällen kann ein Expert Advisor (EA) skriptähnliche Funktionen integrieren, um seine Funktionalität zu erweitern. Das bedeutet, dass Sie innerhalb des EA-Codes bestimmte Aufgaben implementieren können, die den Aktionen ähneln, die normalerweise von eigenständigen Skripten ausgeführt werden. Ein EA kombiniert effektiv Kodierung, anpassbare Einstellungen, Handelslogik und Risikomanagement, um Handelsstrategien effizient zu automatisieren. Nachfolgend habe ich einen Vergleich zwischen dem Skript und dem Expert Advisor (EA) tabellarisch dargestellt.

Skript	Expert Advisor (EA)
Sie sind darauf ausgelegt, eine bestimmte Aufgabe zu erfüllen und die Ausführung fast sofort zu beenden. Sie werden beendet, sobald die Aufgabe erledigt ist, und können nicht kontinuierlich laufen.	Sie laufen kontinuierlich im Hintergrund, überwachen die Marktbedingungen und führen Geschäfte auf der Grundlage vordefinierter Bedingungen aus.
Sie können keine Ereignisse wie Ticks oder Timer verarbeiten. Ein Skript kann seinen Code nur ausführen, wenn es manuell gestartet wird.	Sie können auf Marktereignisse und -veränderungen reagieren (z. B. OnTick, OnTimer, OnTrade), was eine bessere Reaktionsfähigkeit bei Handelsstrategien ermöglicht.
Normalerweise kann ein Skript Handelsgeschäfte ausführen (eröffnen, ändern oder schließen), aber keine laufenden Geschäfte verwalten. Einmal ausgeführt, kann es den Stand der Geschäfte nicht mehr überwachen oder darauf reagieren.	EAs können offene Positionen dynamisch verwalten, Handelsbedingungen verfolgen, Trailing Stops anwenden und ihre Strategien dynamisch an die Marktbedingungen anpassen.
Sie sind in der Regel für eine einmalige Ausführung konzipiert und erfordern möglicherweise bei jeder manuellen Ausführung durch den Nutzer spezifische Konfigurationen (wie Eingabeparameter).	Sie können nutzerdefinierte Parameter sitzungsübergreifend beibehalten und laufen ohne Nutzerinteraktion, sobald sie gestartet sind.
Am besten geeignet für einfache, aktionsbasierte Aufgaben (z. B. das Schließen von Aufträgen im Stapel oder die Anwendung von Indikatoren).	Sie können komplexe Logik, Algorithmen und Systeme beinhalten, die eine ständige Entscheidungsfindung und Anpassung an die Marktbedingungen erfordern.
Skripte können zwar historische Daten analysieren, aber sie können sich nicht kontinuierlich anpassen oder aus neu eingehenden Daten lernen, ohne erneut ausgeführt zu werden.	Sie können historische Daten analysieren und Entscheidungen auf der Grundlage von in Echtzeit eingehenden Daten treffen, was adaptive Strategien ermöglicht.
Da sie schnell ausgeführt und beendet werden, haben sie auch nur begrenzte Auswirkungen auf die Leistung, wenn sie im Vergleich zu kontinuierlich laufenden EAs ausgeführt werden.	Da EAs ständig laufen, können sie zu einem erhöhten CPU- und Speicherverbrauch führen, insbesondere wenn sie viele Trades verwalten oder komplexe Algorithmen verwenden.

Überprüfung des vorherigen Tools (Analytical Comment Tool)

Unser früheres Tool, das Analytical Comment Script, wurde entwickelt, um die wichtigsten Kennzahlen des vorangegangenen Handelstages zu analysieren:

1. Eröffnungskurs des Vortags
2. Schlusskurs des Vortags
3. Volumen des Vortags
4. Aktuelles Tagesvolumen
5. Unterstützungs- und Widerstandsniveaus

Diese Informationen werden in einer vertikal angeordneten Tabelle dargestellt. Darüber hinaus wurde eine Vorhersage möglicher Marktbewegungen auf der Grundlage früherer Eröffnungs- und Schlusskurse sowie des Handelsvolumens berechnet, wie in Abbildung 1 unten dargestellt.

       

Abb. 2. Präsentation der Daten

Unser Skript zeichnete erfolgreich Trendlinien in das Chart ein, die die wichtigsten Unterstützungs- und Widerstandsniveaus hervorhoben. Die Vorhersage der Marktrichtung scheint ebenfalls positiv umgesetzt. In Abbildung 2 fassen wir die Ergebnisse unseres Analysetools als Kommentar zusammen.

Abb. 2. Die Analyseergebnis als Kommentar

Um mehr über das Skript Analytical Comment zu erfahren, klicken Sie bitte auf den folgenden Link: https://www.mql5.com/de/articles/15927

Überblick über den Analytics Master (EA)

Beim Übergang von einem Skript zu einem Expert Advisor (EA) werden einige Informationen, die zuvor vom Skript bereitgestellt wurden, auch weiterhin über den EA zugänglich sein, wie in der Überprüfung des vorherigen Tools erwähnt. Der EA liefert jedoch auch zusätzliche Erkenntnisse und führt Aufgaben aus, die über die Möglichkeiten des ursprünglichen Skripts hinausgehen.

Zusätzlich kann unser EA nun die Marktvolatilität, den Markt-Spread, das Eigenkapital, den Kontostand sowie die minimal und maximal möglichen Losgrößen auf Basis des Kontostandes berechnen. Ich werde weiter erläutern, warum diese Informationen wichtig sind.

• Marktvolatilität

Die Volatilität ist ein statistisches Maß für die Streuung der Daten um ihren Mittelwert über einen bestimmten Zeitraum. Die Berechnung der Marktvolatilität ist für ein effektives Risikomanagement, die Ausführung von Handelsgeschäften und die strategische Planung an den Finanzmärkten von entscheidender Bedeutung. Dieser EA automatisiert die Berechnung der Marktvolatilität und macht den Prozess schlank und nutzerfreundlich. Während die Marktvolatilität in der Regel mit der unten stehenden Formel gemessen wird, vereinfacht unser EA diese Funktion, um sie einfacher nutzen zu können.

Abb. 3. Formel für Volatilität

Zur Berechnung der Volatilität wird zunächst, wie oben beschrieben, die Standardabweichung ermittelt. Um die annualisierte Volatilität zu erhalten, können Sie die Standardabweichung mit der Quadratwurzel aus der Gesamtzahl der Handelstage eines Jahres multiplizieren, die etwa 252 beträgt. Weitere Informationen: https://quantra.quantinsti.com/glossary/Volatility 

• Markt-Spread

Der Markt-Spread, oft auch einfach als „Spread“ bezeichnet, ist die Differenz zwischen dem Geld- und dem Briefkurs für einen bestimmten Vermögenswert auf einem Finanzmarkt. Ein wichtiger Grund für die Kenntnis des Wertes der Markt-Spread ist die Einschätzung der Handelskosten. Die Kenntnis des Spreads hilft Händlern und Anlegern, die mit dem Eingehen und Verlassen von Positionen verbundenen Kosten abzuschätzen.

Ein geringerer Spread deutet in der Regel auf niedrigere Transaktionskosten und eine bessere Handelsausführung hin, was insbesondere für Hochfrequenzhändler oder solche, die täglich zahlreiche Geschäfte abschließen, von entscheidender Bedeutung ist. Umgekehrt kann ein größerer Spread auf höhere Kosten hindeuten und die Händler dazu veranlassen, ihre Strategien zu überdenken oder andere Vermögenswerte für den Handel zu wählen, um die Kosten zu minimieren. Daher wirkt sich die Kenntnis des Markt-Spreads direkt auf die Rentabilität von Geschäften und die Gesamtperformance von Anlagen aus.  

     

Abb. 4. Formel für den Markt-Spread

• Mögliche Losgrößen

Die genaue Berechnung möglicher Losgrößen ist für ein effektives Risikomanagement, diszipliniertes Handeln und eine bessere Gesamtperformance unerlässlich. Sie ermöglicht es den Händlern, fundierte Entscheidungen zu treffen, die Kontrolle über ihre Investitionen zu behalten und sich an die Dynamik der Märkte anzupassen. Die Berechnung der möglichen Losgrößen im vorliegenden Code beruht auf den Grundsätzen des Risikomanagements. Konkret geht es darum, die geeignete Losgröße für einen Handel auf der Grundlage des Kontostands, des gewünschten Risikos pro Handel und des Abstands zum Stop-Loss zu bestimmen. Die Funktion berechnet den Abstand zwischen dem Unterstützungs- und dem Widerstandsniveau (bzw. dem berechneten Stop-Loss und dem Einstiegspunkt). Der StopLossMultiplier bietet eine Möglichkeit, diesen Abstand anzupassen.

Um die Erfahrung des Händlers zu verbessern, wird unser Expert Advisor (EA) die Berechnungen der Marktinformationen vereinfachen und diese Daten alle zwei Stunden aktualisieren. Dadurch wird sichergestellt, dass die Händler stets über die aktuellsten Marktkenntnisse informiert sind, was eine fundiertere Entscheidungsfindung ermöglicht.

Erkunden des Codes des Expert Advisors (Hauptfunktionen und Merkmale)

Der Code umfasst mehrere Funktionalitäten:

• Abrufen und Anzeigen von Handelsdaten für den vergangenen und den aktuellen Tag.
• Analyse der Marktrichtung auf der Grundlage von Preisbewegungen.
• Zeichnen von Trendlinien im Chart.
• Berechnung der Positionsgröße nach den Grundsätzen des Risikomanagements.

Nachfolgend finden Sie den Code für unseren Expert Advisor (EA)

//+------------------------------------------------------------------+
//|                                           Analytics Master EA.mq5|
//|                                Copyright 2024, Christian Benjamin|
//|                                              https://www.mql5,com|
//+------------------------------------------------------------------+
#property copyright   "2024, MetaQuotes Software Corp."
#property link        "https://www.mql5.com/en/users/lynnchris"
#property description "EA for market analysis and commenting"
#property version     "1.0"
#property strict

// Inputs for risk management
input double RiskPercentage = 1.0;        // Percentage of account balance to risk per trade
input double StopLossMultiplier = 1.0;    // Multiplier for determining the stop loss distance
input int ATR_Period = 14;                // Period for ATR calculation

// Global variables for storing values
datetime lastUpdateTime = 0;
double previousDayOpen, previousDayClose, previousDayHigh, previousDayLow;
double previousDayVolume;
double currentDayVolume;
double support, resistance;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   lastUpdateTime = 0; // Set the initial update time
   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ObjectsDeleteAll(0); // Clean up any drawn objects on the current chart
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   UpdateMetrics(); // Call to the function that fetches and displays the metrics
  }

//+------------------------------------------------------------------+
//| Update metrics and display them                                  |
//+------------------------------------------------------------------+
void UpdateMetrics()
  {
// Check if 2 hours have passed since the last update
   if(TimeCurrent() - lastUpdateTime >= 2 * 3600)
     {
      // Fetch previous day's data
      datetime prevDay = iTime(NULL, PERIOD_D1, 1);
      previousDayOpen = iOpen(NULL, PERIOD_D1, 1);
      previousDayClose = iClose(NULL, PERIOD_D1, 1);
      previousDayHigh = iHigh(NULL, PERIOD_D1, 1);
      previousDayLow = iLow(NULL, PERIOD_D1, 1);
      previousDayVolume = iVolume(NULL, PERIOD_D1, 1);

      // Fetch current day's volume
      currentDayVolume = iVolume(NULL, PERIOD_D1, 0); // Volume for today

      // Calculate support and resistance
      support = previousDayLow - (previousDayHigh - previousDayLow) * 0.382; // Fibonacci level
      resistance = previousDayHigh + (previousDayHigh - previousDayLow) * 0.382; // Fibonacci level

      // Determine market direction
      string marketDirection = AnalyzeMarketDirection(previousDayOpen, previousDayClose, previousDayHigh, previousDayLow);

      // Calculate possible lot size based on risk management
      double lotSize = CalculateLotSize(support, resistance);

      // Retrieve account metrics
      double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
      double accountEquity = AccountInfoDouble(ACCOUNT_EQUITY);

      // Calculate market spread manually
      double marketBid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double marketAsk = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double marketSpread = marketAsk - marketBid; // Calculate spread

      double minLotSize = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
      double maxLotSize = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);

      // Calculate market volatility using ATR
      int atrHandle = iATR(NULL, PERIOD_H1, ATR_Period); // Get the ATR handle
      double atrValue = 0.0;

      if(atrHandle != INVALID_HANDLE)  // Check if the handle is valid
        {
         double atrBuffer[]; // Array to hold the ATR values
         if(CopyBuffer(atrHandle, 0, 0, 1, atrBuffer) > 0)  // Copy the latest ATR value
           {
            atrValue = atrBuffer[0]; // Retrieve the ATR value from the buffer
           }
         IndicatorRelease(atrHandle); // Release the indicator handle
        }

      // Create the output string including the last update time
      string lastUpdateStr = TimeToString(TimeCurrent(), TIME_DATE | TIME_MINUTES);
      string infoStr = StringFormat("Prev Day Open: %.2f\nPrev Day Close: %.2f\nPrev Day High: %.2f\nPrev Day Low: %.2f\n"
                                    "Prev Day Volume: %.0f\nCurrent Day Volume: %.0f\nMarket Direction: %s\n"
                                    "Support: %.2f\nResistance: %.2f\nAccount Balance: %.2f\nAccount Equity: %.2f\n"
                                    "Market Spread: %.2f\nMin Lot Size: %.2f, Max Lot Size: %.2f\n"
                                    "Market Volatility (ATR): %.2f\nLast Update Time: %s\nPossible Lot Size: %.2f",
                                    previousDayOpen, previousDayClose, previousDayHigh, previousDayLow,
                                    previousDayVolume, currentDayVolume, marketDirection,
                                    support, resistance, accountBalance, accountEquity, marketSpread,
                                    minLotSize, maxLotSize, atrValue, lastUpdateStr, lotSize);

      // Log the information
      Print(infoStr);

      // Display information on the chart
      Comment(infoStr);

      // Remove old trend lines and create new ones for previous day's high/low
      ObjectsDeleteAll(0);

      // Draw continuous trend lines
      DrawContinuousTrendLine("PrevDayHigh", previousDayHigh);
      DrawContinuousTrendLine("PrevDayLow", previousDayLow);

      // Update last update time
      lastUpdateTime = TimeCurrent();
     }
  }

//+------------------------------------------------------------------+
//| Analyze market direction                                         |
//+------------------------------------------------------------------+
string AnalyzeMarketDirection(double open, double close, double high, double low)
  {
   string direction;

   if(close > open)
     {
      direction = "Bullish";
     }
   else
      if(close < open)
        {
         direction = "Bearish";
        }
      else
        {
         direction = "Neutral";
        }

// Include current trends or patterns based on high and low for further analysis
   if(high > open && high > close)
     {
      direction += " with bullish pressure"; // Example addition for context
     }
   else
      if(low < open && low < close)
        {
         direction += " with bearish pressure"; // Example addition for context
        }

   return direction;
  }

//+------------------------------------------------------------------+
//| Draw a continuous trend line to the left on the chart            |
//+------------------------------------------------------------------+
void DrawContinuousTrendLine(string name, double price)
  {
   datetime startTime = TimeCurrent() - 720 * 3600; // Extend 24 hours into the past
   ObjectCreate(0, name, OBJ_TREND, 0, startTime, price, TimeCurrent(), price);
   ObjectSetInteger(0, name, OBJPROP_COLOR, (StringFind(name, "High") >= 0) ? clrRed : clrBlue);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, 2); // Set thickness of the line
   ObjectSetInteger(0, name, OBJPROP_XSIZE, 0); // Set this property to extend the line infinitely to the left
  }

//+------------------------------------------------------------------+
//| Calculate the lot size based on risk management                  |
//+------------------------------------------------------------------+
double CalculateLotSize(double support, double resistance)
  {
   double stopLossDistance = MathAbs((support - resistance) * StopLossMultiplier);
   double riskAmount = AccountInfoDouble(ACCOUNT_BALANCE) * (RiskPercentage / 100.0);

// Get the tick size for the current symbol
   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);

// Calculate the lot size based on the stop loss and tick size
   double lotSize = riskAmount / (stopLossDistance / tickSize); // Adjusted for the correct pip size
   lotSize = NormalizeDouble(lotSize, 2); // Normalize the lot size to two decimal places

// Ensure lot size is above minimum lot size allowed by broker
   double minLotSize = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   if(lotSize < minLotSize)
      lotSize = minLotSize;

   return lotSize;
  }

//+------------------------------------------------------------------+
//+------------------------------------------------------------------+

Code-Aufschlüsselung

1. Initialisierung und Eigenschaften

input double RiskPercentage = 1.0;         // Percentage of account balance to risk per trade
input double StopLossMultiplier = 1.0;     // Multiplier for determining the stop loss distance
input int ATR_Period = 14;                 // Period for ATR calculation

// Global variables for storing values
datetime lastUpdateTime = 0;
double previousDayOpen, previousDayClose, previousDayHigh, previousDayLow;
double previousDayVolume;
double currentDayVolume;
double support, resistance;

Mit den Eingabeparametern können die Nutzer das Verhalten des EA an ihre Handelsvorlieben anpassen. Globale Variablen werden deklariert, um historische Daten zu speichern, einschließlich Eröffnungs-, Schluss-, Höchst- und Tiefstpreisen vom Vortag sowie Volumen und Unterstützungs-/Widerstandsniveaus.

2. OnInit- und OnDeinit-Funktionen

int OnInit()
{
    lastUpdateTime = 0; // Set the initial update time
    return INIT_SUCCEEDED;
}

OnInit: Diese Funktion wird ausgeführt, wenn der EA initialisiert wird. Sie setzt die letzte Aktualisierungszeit auf Null.

void OnDeinit(const int reason)
{
    ObjectsDeleteAll(0); // Clean up any drawn objects on the current chart
}

OnDeinit: Diese Funktion wird aufgerufen, wenn der EA entfernt oder gestoppt wird, indem alle Chartobjekte gelöscht werden.

3. Hauptlogik in OnTick

void OnTick()
{
    UpdateMetrics(); // Call to the function that fetches and displays the metrics
}

Diese Funktion wird bei jedem Tick (Kursänderung) ausgelöst. Sie ruft die Funktion UpdateMetrics auf, um Daten zu sammeln und zu analysieren.

4. Die Funktion UpdateMetrics

void UpdateMetrics()
{
    if (TimeCurrent() - lastUpdateTime >= 2 * 3600) // Check if 2 hours have passed since last update
    {
        // Fetch previous day's data
        datetime prevDay = iTime(NULL, PERIOD_D1, 1);
        previousDayOpen = iOpen(NULL, PERIOD_D1, 1);
        previousDayClose = iClose(NULL, PERIOD_D1, 1);
        previousDayHigh = iHigh(NULL, PERIOD_D1, 1);
        previousDayLow = iLow(NULL, PERIOD_D1, 1);
        previousDayVolume = iVolume(NULL, PERIOD_D1, 1);
        
        // Fetch current day's volume
        currentDayVolume = iVolume(NULL, PERIOD_D1, 0); // Volume for today
        
        // Calculate support and resistance
        support = previousDayLow - (previousDayHigh - previousDayLow) * 0.382;
        resistance = previousDayHigh + (previousDayHigh - previousDayLow) * 0.382;
        
        // Determine market direction
        string marketDirection = AnalyzeMarketDirection(previousDayOpen, previousDayClose, previousDayHigh, previousDayLow);
        
        // Calculate possible lot size based on risk management
        double lotSize = CalculateLotSize(support, resistance);
        
        // Retrieve account metrics
        double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
        double accountEquity = AccountInfoDouble(ACCOUNT_EQUITY);
        
        // Calculate market spread manually
        double marketBid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
        double marketAsk = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
        double marketSpread = marketAsk - marketBid;

        // Calculate market volatility using ATR
        int atrHandle = iATR(NULL, PERIOD_H1, ATR_Period);
        double atrValue = 0.0;
        
        if (atrHandle != INVALID_HANDLE) // Check if the handle is valid
        {
            double atrBuffer[];
            if (CopyBuffer(atrHandle, 0, 0, 1, atrBuffer) > 0)
            {
                atrValue = atrBuffer[0];
            }
            IndicatorRelease(atrHandle); // Release the indicator handle
        }
        
        // Create the output string including the last update time
        string lastUpdateStr = TimeToString(TimeCurrent(), TIME_DATE | TIME_MINUTES);
        string infoStr = StringFormat("Prev Day Open: %.2f\nPrev Day Close: %.2f\nPrev Day High: %.2f\nPrev Day Low: %.2f\n"
                                       "Prev Day Volume: %.0f\nCurrent Day Volume: %.0f\nMarket Direction: %s\n"
                                       "Support: %.2f\nResistance: %.2f\nAccount Balance: %.2f\nAccount Equity: %.2f\n"
                                       "Market Spread: %.2f\nMin Lot Size: %.2f, Max Lot Size: %.2f\n"
                                       "Market Volatility (ATR): %.2f\nLast Update Time: %s\nPossible Lot Size: %.2f",
                                       previousDayOpen, previousDayClose, previousDayHigh, previousDayLow, 
                                       previousDayVolume, currentDayVolume, marketDirection,
                                       support, resistance, accountBalance, accountEquity, marketSpread,
                                       minLotSize, maxLotSize, atrValue, lastUpdateStr, lotSize);
                                       
        // Log the information
        Print(infoStr);
        
        // Display information on the chart
        Comment(infoStr);
        
        // Remove old trend lines and create new ones for previous day's high/low
        ObjectsDeleteAll(0);
        
        // Draw continuous trend lines
        DrawContinuousTrendLine("PrevDayHigh", previousDayHigh);
        DrawContinuousTrendLine("PrevDayLow", previousDayLow);
        
        // Update last update time
        lastUpdateTime = TimeCurrent();
    }
}

• Zeitkontrolle: Die Funktion wird nur ausgeführt, wenn seit der letzten Aktualisierung 2 Stunden vergangen sind, um übermäßige Berechnungen zu vermeiden.
• Datenabruf: iTime, iOpen, iClose, iHigh, iLow und iVolume werden zur Erfassung der Daten des letzten und des aktuellen Tages verwendet.
• Unterstützung und Widerstand: Das Skript berechnet die Fibonacci-Levels auf der Grundlage der Höchst- und Tiefstkurse des Vortages.
• Analyse der Marktausrichtung: Ruft die Funktion AnalyzeMarketDirection auf, um die Marktbedingungen zu bewerten.
• Berechnung der Losgröße: Ruft die Funktion CalculateLotSize auf, um zu bestimmen, wie viel auf der Grundlage von Risikomanagementprinzipien gehandelt werden soll.
• Konto- und Marktmetriken: Abruf von Kontostand, Eigenkapital und Markt-Spread für bessere Handelsentscheidungen.
• ATR-Berechnung: Ruft die Average True Range (ATR) ab, um die Marktvolatilität zu messen.
• Informationen zur Ausgabe: Formatiert und zeigt relevante Metriken in der infoStr-Zeichenkette an und protokolliert sie mit Print.
• Erstellen von Trendlinien: Bereinigt alte Trendlinien und erstellt neue auf der Grundlage der Höchst- und Tiefstkurse des Vortags.

5. Analyse der Marktausrichtung

string AnalyzeMarketDirection(double open, double close, double high, double low)
{
    string direction;
    
    if (close > open)
    {
        direction = "Bullish";
    }
    else if (close < open)
    {
        direction = "Bearish";
    }
    else
    {
        direction = "Neutral";
    }

    // Include current trends or patterns based on high and low for further analysis
    if (high > open && high > close)
    {
        direction += " with bullish pressure"; // Example addition for context
    }
    else if (low < open && low < close)
    {
        direction += " with bearish pressure"; // Example addition for context
    }
    
    return direction;
}

• Bestimmen Sie die Marktrichtung: Diese Funktion verwendet die Eröffnungs-, Schluss-, Höchst- und Tiefstkurse des Vortages, um festzustellen, ob der Markt steigt, fällt oder sich seitwärts bewegt.
• Zusätzliche Einblicke: Sie prüft auf Druckindikatoren auf der Grundlage von Höchst- und Tiefstständen und bietet so eine kontextbezogenere Analyse der Marktbedingungen.

6. Zeichnen von Trendlinien

void DrawContinuousTrendLine(string name, double price)
{
    datetime startTime = TimeCurrent() - 24 * 3600; // Extend 24 hours into the past
    ObjectCreate(0, name, OBJ_TREND, 0, startTime, price, TimeCurrent(), price);
    ObjectSetInteger(0, name, OBJPROP_COLOR, (StringFind(name, "High") >= 0) ? clrRed : clrBlue);
    ObjectSetInteger(0, name, OBJPROP_WIDTH, 2); // Set thickness of the line
    ObjectSetInteger(0, name, OBJPROP_XSIZE, 0); // Set this property to extend the line infinitely to the left
}

• Zeichnen von Trendlinien: Diese Funktion erstellt eine Trendlinie im Chart für den Höchst- oder Tiefststand des Vortages, die 24 Stunden zurückreicht.
• Anpassungen: Jede Linie hat eine Farbe (rot für oben, Widerstand, und blau für tief, Unterstützung) und eine bestimmte Breite.

7. Berechnung der Losgröße

double CalculateLotSize(double support, double resistance)
{
    double stopLossDistance = MathAbs((support - resistance) * StopLossMultiplier);
    double riskAmount = AccountInfoDouble(ACCOUNT_BALANCE) * (RiskPercentage / 100.0);
    
    // Get the tick size for the current symbol
    double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
    
    // Calculate the lot size based on the stop loss and tick size
    double lotSize = riskAmount / (stopLossDistance / tickSize);
    lotSize = NormalizeDouble(lotSize, 2); // Normalize the lot size to two decimal places

    // Ensure lot size is above minimum lot size allowed by broker
    double minLotSize = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
    if (lotSize < minLotSize)
        lotSize = minLotSize;

    return lotSize;
}

• Risikomanagement: Diese Funktion berechnet die Losgröße auf der Grundlage des festgelegten Risikoprozentsatzes in Bezug auf den Kontostand des Nutzers und den berechneten Stop-Loss-Abstand.
• Normalisierung: Stellt sicher, dass die Losgröße innerhalb der vom Makler festgelegten Grenzen liegt.

Code-Implementierung und -Prüfung

Implementierung eines Expert Advisor (EA) auf MetaTrader 5: Ein schrittweiser Leitfaden

• Öffnen Sie MetaTrader 5: Starten Sie die Handelsplattform MetaTrader 5 auf Ihrem Computer.
• Zugriff auf MetaEditor: Um MetaEditor zu öffnen, klicken Sie in der Menüleiste auf Extras > MetaQuotes Language Editor oder drücken Sie einfach F4. Wenn Sie MetaEditor separat installiert haben, können Sie ihn auch direkt ausführen.
• Setzen Sie den EA ein: Wählen Sie in MetaEditor Datei > Neu > Expert Advisor oder öffnen Sie eine vorhandene EA-Datei (.mq5). Wenn Sie einen neuen EA erstellen, folgen Sie den Aufforderungen, ihn zu benennen und zu definieren.
• Kompilieren Sie den EA: Nachdem Sie Ihren EA-Code bearbeitet haben, klicken Sie auf die Schaltfläche Kompilieren (oder drücken Sie F7). Vergewissern Sie sich, dass keine Fehler aufgetreten sind; eine erfolgreiche Kompilierung erzeugt eine ausführbare Datei.
• Laden Sie den EA in MetaTrader 5: Kehren Sie zur MetaTrader 5-Plattform zurück und öffnen Sie das Navigator-Panel (Strg + N). Sie finden Ihren kompilierten EA im Bereich Expert Advisors.
• Hängen Sie den EA an ein Chart an: Ziehen Sie den EA auf den gewünschten Chart, oder klicken Sie mit der rechten Maustaste auf den EA und wählen Sie An einen Chart anhängen. Es erscheint ein Einstellungsfenster für die Anpassung der Parameter.
• Aktivieren Sie den automatisierten Handel: Vergewissern Sie sich, dass AutoTrading aktiviert ist, indem Sie auf die grüne AutoTrading-Schaltfläche in der MetaTrader 5-Symbolleiste klicken. Wenn Sie dazu aufgefordert werden, aktivieren Sie die Option Automatischen Handel zulassen in den EA-Einstellungen.
• Leistung überwachen: Behalten Sie die Leistung des EA im Chart im Auge. Verwenden Sie den Strategy Tester für Backtests, falls erforderlich.
• Passen Sie die Einstellungen nach Bedarf an: Sie können Parameter oder Einstellungen direkt im EA-Einstellungsfenster ändern, indem Sie mit der rechten Maustaste auf den Chart klicken.

Abb. 5. Analyse Ergebnis  

Abbildung 5 veranschaulicht die Verknüpfung des EA mit dem Chart, was zu den angezeigten Ergebnissen führt.

Abb. 6. Analyse Ergebnis 

Die obige Abbildung 6 veranschaulicht die Gesamtleistung unseres Expert Advisors (EA), der in der Lage ist, die wichtigsten Marktkennzahlen automatisch zu berechnen und sie in einem Chart darzustellen. Der EA zeichnet Trendlinien, die auf den Unterstützungs- und Widerstandsniveaus des Vortags basieren. Es aktualisiert die Marktinformationen regelmäßig alle zwei Stunden, wie in den letzten beiden Diagrammen zu sehen ist, die auch die Zeitstempel der letzten Aktualisierungen enthalten.                    

                                                                             

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass der erfolgreiche Einsatz des Analytics Master EA einen bedeutenden Schritt nach vorne im automatisierten Handel darstellt. Dieser EA automatisiert nicht nur die Analyse der wichtigsten Marktkennzahlen, sondern bietet auch wertvolle Einblicke in Unterstützungs- und Widerstandsniveaus, die Händlern helfen, intelligentere Entscheidungen zu treffen. Durch die Integration eines effektiven Risikomanagements und die Bereitstellung von Echtzeit-Updates unterstützt es Händler dabei, die Komplexität des Marktes sicher zu steuern. Insgesamt verbessert dieses Tool die Handelseffizienz und ermöglicht es den Nutzern, bei ihren Handelsstrategien informiert und proaktiv zu bleiben.

Nehmen Sie sich die Zeit, den EA anhand historischer Daten zu testen, um seine Leistung unter verschiedenen Marktbedingungen zu verstehen. So können Sie die Einstellungen an Ihren Handelsstil anpassen. Regelmäßige Überprüfung der von der EA bereitgestellten Metriken und Erkenntnisse. Da sich die Marktbedingungen schnell ändern können, ist es wichtig, immer auf dem Laufenden zu bleiben, um rechtzeitig Entscheidungen treffen zu können. Halten Sie sich stets an Ihre Risikomanagementstrategie. Passen Sie die prozentualen Risikoeinstellungen an Ihre persönliche Risikotoleranz und Kontogröße an. Nutzen Sie Ausbildungsressourcen zu Handelsstrategien, Marktverhalten und technischer Analyse, um die Erkenntnisse des EA zu ergänzen. Wenn Sie auf Probleme stoßen oder Verbesserungsvorschläge haben, sollten Sie dem Entwickler Feedback geben. Die Anregungen der Nutzer sind für künftige Verbesserungen von unschätzbarem Wert.

Wenn Sie diese Empfehlungen befolgen, können Sie die Effektivität des Analytics Master EA maximieren und Ihre Handelserfahrung insgesamt verbessern.

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	Erstes Werkzeug in Lynnchris Tool Chest
18/11/24	Analytical Comment	Er liefert Informationen zum Vortag in Tabellenform und nimmt die zukünftige Marktentwicklung vorweg.	1.0	Erste Veröffentlichung	Zweites Werkzeug in Lynnchris Tool Chest
27/11/24	Analytics Master	Regelmäßige Aktualisierung der Marktmetriken alle zwei Stunden	1.01	Zweite Veröffentlichung	Drittes Werkzeug in Lynnchris Tool Chest