Formulierung eines dynamischen Multi-Pair EA (Teil 3): Mean-Reversion- und Momentum-Strategien

Einführung

In diesem Artikel wird gezeigt, wie eine Logik strukturiert werden kann, die sich an die Marktdynamik anpasst, wiederholte Signale während ausgedehnter Bewegungen vermeidet und sicherstellt, dass Handelseinträge mit Präzision unter Verwendung statistischer Schwellenwerte vorgenommen werden, während sie über mehrere Symbole in Echtzeit skaliert werden. Eine der häufigsten Herausforderungen, mit denen Händler konfrontiert werden, ist die Signalmüdigkeit, bei der Systeme während starker Trends oder staken Schwankungen weiterhin Handelseinträge in dieselbe Richtung generieren, was zu übermäßigem Handel und unnötigen Verlusten führt. In schnellen oder unentschlossenen Märkten können Strategien, denen es an Kontext oder Momentum-Bewusstsein mangelt, Opfer von falschen Signalen, späten Einstiegen und schlechter Risikoallokation über korrelierte Währungspaare werden.

Um dieses Problem zu lösen, führen wir einen dynamischen, paarübergreifenden Handelsrahmen ein, der die Strategien von der Rückkehr zum Mittelwert (mean reversion) und dem Momentum in einer einzigen intelligenten Engine kombiniert. Anstatt sich nur auf traditionelle Indikatoren zu verlassen, nutzt das System Z-Score-Berechnungen, um statistisch signifikante Preisabweichungen und Schwellenwerte für die Schwankungsbreite zu erkennen, um zu entscheiden, wann man in den Handel einsteigt, ihn aussetzt oder wieder aufnimmt. Durch die Verfolgung der Handelsrichtung, des Einstiegsfortschritts und der symbolspezifischen Bedingungen in Echtzeit kann der EA effektiv pausieren oder den Einstieg fortsetzen, je nachdem, wie viel von der aktuellen Preisbewegung bereits stattgefunden hat.

In diesem Artikel wird die technische Umsetzung dieser Ideen erläutert, wobei der Schwerpunkt darauf liegt, wie die Logik über mehrere Paare hinweg effizient verwaltet werden kann, wie sichergestellt werden kann, dass Handelsgeschäfte nur dann getätigt werden, wenn die Bedingungen optimal sind, und vom Rauschen verursachte Entscheidungen reduziert werden können. Egal, ob Sie einen robusten EA erstellen oder ein diskretionäres System verfeinern, dieser Ansatz fördert eine intelligentere Handelsauswahl, ein besseres Timing und ein anpassungsfähigeres Risikoprofil für moderne Marktumgebungen.

Expertenlogik

Die Rückkehr zum Mittelwert ist ein Handelskonzept, das auf der Vorstellung beruht, dass die Kurse im Laufe der Zeit dazu tendieren, zu ihrem durchschnittlichen oder „mittleren“ Wert zurückzukehren. Diese Theorie geht davon aus, dass extreme Preisbewegungen, ob nach oben oder nach unten, vorübergehend sind und sich schließlich in Richtung einer historischen Norm korrigieren werden. Auf den Finanzmärkten werden diese Extreme häufig durch kurzfristige Ungleichgewichte bei Angebot und Nachfrage, Überreaktionen auf Nachrichten oder Liquiditätsschocks verursacht. Strategien der Rückkehr zum Mittelwert zielen darauf ab, aus diesen vorübergehenden Preisverwerfungen Kapital zu schlagen, indem sie erkennen, wann ein Vermögenswert statistisch gesehen überkauft oder überverkauft ist, und dann in der Erwartung, dass der Preis zu seinem Mittelwert zurückkehren wird, in die entgegengesetzte Richtung handeln.

Unter der Haube wird die Umkehrung des Mittelwerts in der Regel mit statistischen Instrumenten wie dem Z-Score umgesetzt, der misst, wie weit der aktuelle Kurs von einem gleitenden Durchschnitt in Form von Standardabweichungen abweicht. Ein hoher positiver Z-Score deutet darauf hin, dass der Kurs weit über seinem Durchschnitt liegt (potenziell überkauft), während ein niedriger negativer Z-Score darauf hindeutet, dass er weit darunter liegt (potenziell überverkauft). Die Händler legen Schwellenwerte fest (z. B. +-2,0), um zu bestimmen, wann eine Abweichung signifikant genug ist, um einen Handel zu rechtfertigen. Sobald der Schwellenwert überschritten wird und zusätzliche Bedingungen (wie eine nachlassende Dynamik oder ein Umkehrsignal) erfüllt sind, wird ein Handel in der Erwartung eröffnet, dass der Preis zum Mittelwert zurückkehrt. Diese Strategie ist am effektivsten in schwankenden oder sich zum Mittelwert zurückkehrenden Märkten und erfordert ein sorgfältiges Risikomanagement, da anhaltende Trends die Umkehrsignale ungültig machen können, wenn sie nicht berücksichtigt werden.

Der Handel des Momentums ist eine Strategie, die darauf abzielt, von der Fortsetzung bestehender Markttrends zu profitieren. Der Grundgedanke ist, dass Vermögenswerte, die sich stark in eine Richtung entwickelt haben, sich mit größerer Wahrscheinlichkeit weiter in diese Richtung bewegen werden, anstatt sich umzukehren (Reversion). Dieses Verhalten wird häufig durch Herdenpsychologie, institutionelle Strömungen, nachrichtengetriebene Stimmungen oder technische Ausbrüche bestimmt. Händler, die Momentum-Strategien anwenden, zielen darauf ab, in der frühen oder mittleren Phase einer starken Richtungsbewegung in den Handel einzusteigen und dem Trend zu folgen, bis sich Anzeichen einer Erschöpfung oder Umkehr zeigen.

Unter der Haube beruhen Momentum-Strategien in der Regel auf der Preisänderungsrate über einen bestimmten Zeitraum. Dies kann anhand von einfachen Preisdifferenzen (z. B. aktueller Preis minus Preis von vor N Bars), Momentum-Oszillatoren oder sogar nutzerdefinierten Indikatoren, die die Geschwindigkeit und Beschleunigung des Preises erfassen, gemessen werden. In einem Handelssystem mit mehreren Paaren kann das Momentum für jedes Symbol einzeln berechnet und dann anhand eines Schwellenwerts bewertet werden, um festzustellen, ob die Bewegung stark genug ist, um einen Einstieg zu rechtfertigen. Sobald das Momentum bestätigt ist, wird in Richtung des Trends gehandelt, und die Strategie kann weiterhin Positionen aufbauen, solange das Momentum stark und nicht erschöpft ist.

Erste Schritte

//+------------------------------------------------------------------+
//|                                                Dyna Mean&Mom.mq5 |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#include <Trade/Trade.mqh>
#include <Math/Stat/Math.mqh>
CTrade trade;

Wie immer fangen wir damit an, die notwendigen Klassen einzubinden, damit unser Expert Advisor richtig funktioniert. Was dieses Mal vielleicht anders aussieht, ist, dass wir auch die Bibliothek <Math/Stat/Math.mqh> einbeziehen. Dies ermöglicht uns den Zugang zu leistungsstarken statistischen Tools wie Mittelwert-, Standardabweichungs- und Z-Score-Berechnungen, die für die Umsetzung der Mean-Reversion- und Momentum-Strategien unerlässlich sind.

//+------------------------------------------------------------------+
//|  Enhanced Mean-Reversion + Momentum EA                           |
//+------------------------------------------------------------------+

//--- Input settings
input string Symbols = "XAUUSD,GBPUSD,USDCAD,USDJPY";
input int    TakeProfit = 150;        // TP in points
input int    StopLoss = 100;           // SL in points
input int    MAPeriod = 20;
input int    MomentumPeriod = 5;
input double Z_Threshold = 2.0;
input double Mom_Threshold = 1.5;     // Price change in standard deviations
input double RiskPercent_High = 1.5, RiskPercent_Mod = 1.0, RiskPercent_Low = 0.5;

In diesem Abschnitt des Codes werden die Eingabeeinstellungen für den Expert Advisor festgelegt. Damit kann der Nutzer eine Liste von Handelssymbolen (z. B. XAUUSD, GBPUSD) angeben, wichtige Risikomanagementparameter wie Take-Profit, Stop-Loss und Risikoprozentsätze festlegen und das Verhalten der Strategie mithilfe statistischer Eingaben feinabstimmen. Dazu gehören der Zeitraum für den gleitenden Durchschnitt, der Zeitraum für die Messung der Dynamik und die Schwellenwerte für den Z-Score und die Stärke der Dynamik. Zusammen helfen diese Eingaben dem EA, sich an unterschiedliche Marktbedingungen anzupassen und das Risiko über mehrere Währungspaare hinweg zu managen.

//--- Global parameters
string symb_List[];
int Num_symbs = 0;

// Indicator handles arrays
int MA_hndl[];
int STDev_hndl[];
int ATR_hndl[];

Hier deklarieren wir globale Variablen, die im gesamten EA verwendet werden. Sie enthält „symb_List[]“, ein Array zur Aufnahme der Liste der Handelssymbole, und „Num_symbs“, das die Gesamtzahl der zu verarbeitenden Symbole speichert. Zusätzlich definieren wir Arrays für Indikator-Handles: „MA_hndl[]“ für den gleitenden Durchschnitt, „STDev_hndl[]“ für die Standardabweichung und „ATR_hndl[]“ für den durchschnittlichen wahren Bereich. Diese Handles werden verwendet, um Indikatordaten für jedes Symbol während der Ausführung effizient zu verwalten und darauf zuzugreifen.

//+------------------------------------------------------------------+
//| Expert initialization                                            |
//+------------------------------------------------------------------+
int OnInit() {
    //--- Split symbol list
    ushort separator = StringGetCharacter(",", 0);
    StringSplit(Symbols, separator, symb_List);
    Num_symbs = ArraySize(symb_List);

    //--- Resize arrays
    ArrayResize(MA_hndl, Num_symbs);
    ArrayResize(STDev_hndl, Num_symbs);
    ArrayResize(ATR_hndl, Num_symbs);

    //--- Prepare each symbol
    for (int i = 0; i < Num_symbs; i++) {
        string symbol = symb_List[i];
        StringTrimLeft(symbol);
        StringTrimRight(symbol);
        
        //--- Create indicator handles
        MA_hndl[i] = iMA(symbol, PERIOD_H1, MAPeriod, 0, MODE_SMA, PRICE_CLOSE);
        STDev_hndl[i] = iStdDev(symbol, PERIOD_H1, MAPeriod, 0, MODE_SMA, PRICE_CLOSE);
        ATR_hndl[i] = iATR(symbol, PERIOD_H1, 14);
        
        if (MA_hndl[i] == INVALID_HANDLE || STDev_hndl[i] == INVALID_HANDLE || ATR_hndl[i] == INVALID_HANDLE) {
            Print("Failed to create indicator handles for ", symbol);
            return INIT_FAILED;
        }
    }
    
    //--- Set magic number for trade identification
    trade.SetExpertMagicNumber(54321);
    
    return INIT_SUCCEEDED;
}

In diesem Abschnitt wird der Expert Advisor initialisiert, wenn er in den Chart geladen wird. Wir beginnen mit der Aufteilung der nutzerdefinierten Zeichenkette der Symbole in ein Array und zählen, wie viele Symbole verarbeitet werden sollen. Anschließend wird die Größe der Arrays der Indikator-Handles an die Anzahl der Symbole angepasst. Für jedes Symbol werden alle überflüssigen Leerzeichen entfernt und Indikator-Handles für den gleitenden Durchschnitt (MA), die Standardabweichung (STDev) und die durchschnittliche wahre Spanne (ATR) erstellt, die alle auf dem H1-Zeitrahmen berechnet werden. Wenn eines der Handles nicht initialisiert werden kann, gibt der EA eine Fehlermeldung aus und endet sich. Zum Schluss setzen wir mit „trade.SetExpertMagicNumber(54321)“ eine eindeutige magische Zahl, um die von diesem EA platzierten Trades zu identifizieren.

//+------------------------------------------------------------------+
//|          Mean and Momentum Signal Generator                      |
//+------------------------------------------------------------------+
void MeanAndMomentum(string symbol, int idx) {
    //--- Get current price data
    MqlRates current[];
    if(CopyRates(symbol, PERIOD_H1, 0, 1, current) < 1) return;
    double close = current[0].close;
    
    //--- Get historical price for momentum calculation
    MqlRates historical[];
    if(CopyRates(symbol, PERIOD_H1, MomentumPeriod, 1, historical) < 1) return;
    double histClose = historical[0].close;
    
    //--- Get indicator values
    double ma[1], stddev[1], atr[1];
    if(CopyBuffer(MA_hndl[idx], 0, 0, 1, ma) < 1) return;
    if(CopyBuffer(STDev_hndl[idx], 0, 0, 1, stddev) < 1) return;
    if(CopyBuffer(ATR_hndl[idx], 0, 0, 1, atr) < 1) return;
    
    //--- Calculate metrics
    double momentum = close - histClose;
    double zscore = (stddev[0] > 0) ? (close - ma[0]) / stddev[0] : 0;
    double momThreshold = Mom_Threshold * stddev[0]; // Dynamic momentum threshold
    
    //--- Determine signal type
    int signal = 0;
    double riskPercent = 0;
    
    bool meanReversionLong = (zscore < -Z_Threshold);
    bool meanReversionShort = (zscore > Z_Threshold);
    bool momentumLong = (momentum > momThreshold);
    bool momentumShort = (momentum < -momThreshold);
    
    //--- Signal priority: Momentum > Mean Reversion
    if(momentumLong && meanReversionLong) {
        signal = 1;
        riskPercent = RiskPercent_High; // Strong signal
    }
    else if(momentumShort && meanReversionShort) {
        signal = -1;
        riskPercent = RiskPercent_High;
    }
    else if(momentumLong) {
        signal = 1;
        riskPercent = RiskPercent_Mod;
    }
    else if(momentumShort) {
        signal = -1;
        riskPercent = RiskPercent_Mod;
    }
    else if(meanReversionLong) {
        signal = 1;
        riskPercent = RiskPercent_Low;
    }
    else if(meanReversionShort) {
        signal = -1;
        riskPercent = RiskPercent_Low;
    }
    
    //--- Exit if no signal
    if(signal == 0) return;
    
    //--- Check existing positions
    if(PositionSelect(symbol)) {
        long positionType = PositionGetInteger(POSITION_TYPE);
        if((positionType == POSITION_TYPE_BUY && signal == 1) || 
           (positionType == POSITION_TYPE_SELL && signal == -1)) {
            return; // Already in position in same direction
        }
        else {
            // Close opposite position before opening new one
            trade.PositionClose(symbol);
            Sleep(100); // Allow time for order execution
        }
    }
    
    //--- Calculate position size
    double lotSize = CalculatePositionSize(symbol, riskPercent, atr[0]);
    if(lotSize <= 0) return;
    
    //--- Execute trade
    ExecuteTrade(signal == 1 ? ORDER_TYPE_BUY : ORDER_TYPE_SELL, symbol, lotSize);
}

Die Funktion „MeanAndMomentum()“ generiert Handelssignale durch die Kombination von der Rückkehr zum Mittelwert und dem Momentum für ein bestimmtes Symbol. Zunächst werden der jüngste Kurs (Close) und ein historischer Kurs von vor der „MomentumPeriode“ abgerufen, der zur Berechnung des Momentums verwendet wird. Außerdem werden Werte für den gleitenden Durchschnitt, die Standardabweichung und die Average True Range (ATR) mit Hilfe von zuvor initialisierten Indikator-Handles abgerufen. Mit diesen Daten berechnet die Funktion den Z-Score, der angibt, wie weit der aktuelle Kurs in Standardabweichungen vom Mittelwert entfernt ist, und die Dynamik, die einfach die Kursveränderung im Zeitverlauf darstellt. Durch Skalierung der Standardabweichung wird auch ein dynamischer Schwellenwert für die Dynamik berechnet, sodass das System auf veränderte Volatilitätsbedingungen reagieren kann.

Sobald diese Metriken berechnet sind, bewertet die Funktion, ob die Bedingungen für ein Handelssignal erfüllt sind. Es wird geprüft, ob der Z-Score auf eine Möglichkeit zu Rückkehr zum Mittelwert hinweist (Preis weit vom Durchschnitt entfernt) oder ob das Momentum stark genug ist, um auf eine Trendbewegung hinzuweisen. Die Signallogik ist gestaffelt und räumt den Fällen Priorität ein, in denen sowohl die Rückkehr zum Mittelwert als auch das Momentum in dieselbe Richtung gehen, und weist ihnen die höchste Risikozuweisung (RiskPercentage_High) zu. Wenn nur eine Bedingung erfüllt ist, weist das System einen niedrigeren Risikoprozentsatz zu. Dieser mehrschichtige Ansatz hilft dem EA, qualitativ hochwertigere Setups herauszufiltern und sein Engagement auf der Grundlage des Signals anzupassen.

Schließlich prüft die Funktion, ob es bereits Positionen für dasselbe Symbol gibt. Wenn bereits eine Position in der gleichen Richtung existiert, wird eine Doppelung vermieden. Wenn es eine gegenüberliegende Position gibt, wird diese geschlossen, bevor die neue Position geöffnet wird. Die Funktion berechnet dann die geeignete Losgröße anhand des ATR-basierten Risikomodells und führt den Handel unter Verwendung der festgelegten Signalrichtung aus. Diese Struktur stellt sicher, dass der Handel mit dem statistischen Entsprechungen übereinstimmt, auf der Grundlage der Volatilität richtig bemessen ist und nicht mit dem bestehenden Marktengagement kollidiert.

//+------------------------------------------------------------------+
//| Calculate position size based on risk and volatility             |
//+------------------------------------------------------------------+
double CalculatePositionSize(string symbol, double riskPercent, double atrValue) {
    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
    double riskAmount = balance * (riskPercent / 100.0);
    
    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
    double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE_LOSS);
    double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
    
    if(point <= 0 || tickValue <= 0 || tickSize <= 0) {
        Print("Invalid symbol parameters for ", symbol);
        return 0;
    }
    
    // Use ATR-based stop loss
    double slDistance = atrValue * 1.5;
    double lossPerLot = slDistance * (tickValue / tickSize);
    
    if(lossPerLot <= 0) {
        Print("Invalid loss calculation for ", symbol);
        return 0;
    }
    
    double lots = riskAmount / lossPerLot;
    lots = NormalizeLots(symbol, lots);
    
    return lots;
}

Die Funktion „CalculatePositionSize()“ bestimmt die optimale Losgröße für einen Handel auf der Grundlage des Kontostands des Händlers, des gewählten Risikoprozentsatzes und der aktuellen Marktvolatilität, gemessen durch die Average True Range (ATR). Zunächst wird berechnet, wie viel Kapital der Händler bereit ist zu riskieren (riskAmount), und zwar als Prozentsatz des gesamten Kontosaldos. Anschließend werden die wichtigsten Handelsparameter für das angegebene Symbol abgerufen, einschließlich Punkt-Größe, Tick-Wert und Tick-Größe, die für die Umwandlung von Kursbewegungen in ein monetäres Risiko erforderlich sind.

Anhand dieser Parameter schätzt die Funktion den Abstand von Stop-Loss, indem sie den Wert des ATR mit 1,5 multipliziert und so einen volatilitätsangepassten Puffer berücksichtigt. Es berechnet den potenziellen Verlust pro Standard-Lot auf der Grundlage dieser Stopp-Distanz und des symbolspezifischen Tick-Wertes. Die gewünschte Losgröße wird dann berechnet, indem der Risikobetrag durch den geschätzten Verlust pro Los geteilt wird, um sicherzustellen, dass der Handel innerhalb der festgelegten Risikotoleranz liegt. Abschließend ruft es „NormalizeLots()“ auf, um die Losgröße entsprechend den Handelsbeschränkungen des Symbols zu runden, und gibt das Ergebnis zurück. Diese Methode stellt sicher, dass jeder Handel sowohl für das Konto als auch für die Marktbedingungen angemessen dimensioniert ist.

//+------------------------------------------------------------------+
//| Normalize lot size to broker requirements                        |
//+------------------------------------------------------------------+
double NormalizeLots(string symbol, double lots) {
    double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
    double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
    double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
    
    if(lotStep > 0) {
        lots = MathRound(lots / lotStep) * lotStep;
    }
    
    lots = MathMax(minLot, MathMin(maxLot, lots));
    return lots;
}

Hier normalisiert die Funktion einfach die Losgröße entsprechend den Anforderungen des Brokers.

//+------------------------------------------------------------------+
//| Execute trade with proper risk management                        |
//+------------------------------------------------------------------+
void ExecuteTrade(ENUM_ORDER_TYPE tradeType, string symbol, double lotSize) {
    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
    double price = (tradeType == ORDER_TYPE_BUY) ? 
                   SymbolInfoDouble(symbol, SYMBOL_ASK) : 
                   SymbolInfoDouble(symbol, SYMBOL_BID);
    
    // Get current ATR for dynamic stop levels
    double atr[1];
    int idx = ArrayPosition(symbol);
    if(idx >= 0 && CopyBuffer(ATR_hndl[idx], 0, 0, 1, atr) > 0) {
        double slDistance = atr[0] * 1.5;
        double tpDistance = atr[0] * 2.5;
        
        double sl = (tradeType == ORDER_TYPE_BUY) ? 
                    price - slDistance : 
                    price + slDistance;
                    
        double tp = (tradeType == ORDER_TYPE_BUY) ? 
                    price + tpDistance : 
                    price - tpDistance;
        
        trade.PositionOpen(symbol, tradeType, lotSize, price, sl, tp, "MR-Mom System");
    }
    else {
        // Fallback to fixed stops if ATR fails
        double sl = (tradeType == ORDER_TYPE_BUY) ? 
                    price - (StopLoss * point) : 
                    price + (StopLoss * point);
                    
        double tp = (tradeType == ORDER_TYPE_BUY) ? 
                    price + (TakeProfit * point) : 
                    price - (TakeProfit * point);
        
        trade.PositionOpen(symbol, tradeType, lotSize, price, sl, tp, "MR-Mom System");
    }
}

Die Funktion „ExecuteTrade()“ ist für die Platzierung eines Handels mit angemessenen Risikokontrollen auf der Grundlage der Handelsrichtung, des Symbols und der berechneten Losgröße verantwortlich. Es beginnt mit der Ermittlung des aktuellen Marktpreises unter Verwendung des Briefkurses (ask) bei Kaufgeschäften und des Geldkurses (bid) bei Verkaufsgeschäften und versucht dann, den letzten ATR-Wert für dieses Symbol abzurufen. Wenn die ATR-Daten verfügbar sind, werden sie zur dynamischen Berechnung von Stop-Loss- und Take-Profit verwendet: 1,5×ATR für den Stop-Loss und 2,5×ATR für den Take-Profit, um sicherzustellen, dass Risiko und Ertrag an die aktuelle Marktvolatilität angepasst werden. Der Handel wird dann mit der Methode „trade.PositionOpen()“ mit diesen berechneten Niveaus und einem Label zur Identifizierung platziert.

//+------------------------------------------------------------------+
//| Find symbol position in array                                    |
//+------------------------------------------------------------------+
int ArrayPosition(string symbol) {
    for(int i = 0; i < Num_symbs; i++) {
        if(symb_List[i] == symbol) return i;
    }
    return -1;
}

Die Funktion sucht nach einem bestimmten Symbol im Array „symb_List“ und gibt dessen Index zurück, wenn die Symbole nicht gefunden werden, gibt sie -1 zurück. Es hilft, die richtige Position des Symbols für den Zugriff auf die zugehörigen Indikatorgriffe zu identifizieren.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick(){
   if(isNewBar()){
      for(int i = 0; i < Num_symbs; i++) {
         MeanAndMomentum(symb_List[i], i);
      }
   }
}

Die Funktion „OnTick()“ schließlich ist das Herzstück des Expert Advisors, das jedes Mal, wenn ein neuer Tick empfangen wird, eine Logik ausführt. Um eine Verarbeitung bei jedem Tick zu vermeiden, wird zunächst mit „isNewBar()“ geprüft, ob sich ein neuer Balken gebildet hat, sodass die Signale nur einmal pro Kerze ausgewertet werden. Wenn ein neuer Balken bestätigt wird, durchläuft die Funktion alle angegebenen Symbole und ruft „MeanAndMomentum()“ für jedes einzelne auf, sodass der EA Handelsmöglichkeiten für mehrere Paare synchron mit den neuesten Marktdaten bewerten kann.

Ergebnisse des Backtests

Die Backtests wurde für den 1H-Zeitrahmen über ein zweimonatiges Testfenster (01. Mai 2025 bis 20. Juni 2025) mit den folgenden Eingabeeinstellungen bewertet:

• TP in Punkten = 972
• SL in Punkten = 846
• MA-Zeitraum = 80
• Impulsperiode = 43
• Z_Schwellenwert = 3,0
• Preisänderung in Standardabweichungen = 4,05
• Risikoprozent hoch = 9,75
• Risikoprozent mod = 10,0
• Risikoprozent niedrig = 4,65

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass wir einen dynamischen Multi-Symbol Expert Advisor entwickelt und implementiert haben, der sowohl die Handelsstrategien der Rückkehr zum Mittelwert als auch dem Momentum kombiniert, um sich auf intelligente Weise an die sich verändernden Marktbedingungen anzupassen. Durch den Einsatz statistischer Instrumente wie gleitende Durchschnitte, Standardabweichung (Z-Score) und ATR-basierte Volatilität haben wir ein System aufgebaut, das mehrere Paare gleichzeitig analysieren und kalkulierte Handelsentscheidungen treffen kann. Jedes Symbol wird unabhängig überwacht, was eine individuelle Signalgenerierung auf der Grundlage von Preisverhalten, Volatilität und Trendstärke ermöglicht. Die Strategie priorisiert Einstiege, wenn die Signale vom Momentum und der Rückkehr zum Mittelwert übereinstimmen, und nutzt eine risikoangepasste Positionsgröße, um das Engagement effektiv zu steuern.

Zusammenfassend lässt sich sagen, dass dieser Expert Advisor eine solide Grundlage für den Aufbau statistisch basierter, adaptiver Handelssysteme für mehrere Währungspaare bietet. Dank seines modularen Aufbaus und seines mehrschichtigen Entscheidungsfindungsrahmens ist er sowohl skalierbar als auch anpassbar und eignet sich für Strategien, die vom Scalping bis zum Swing Trading reichen. Der Einsatz von Echtzeit-Volatilitäts- und Momentum-Tracking stellt sicher, dass Einträge nicht nur statistisch fundiert, sondern auch marktsensitiv sind. Mit der richtigen Optimierung und Überwachung hat dieses System das Potenzial, eine konsistente, risikogesteuerte Performance in einer Vielzahl von Marktumgebungen zu liefern.