Balance_Reset - Bibliothek für den MetaTrader 5

Aktualisierung:

Ich habe diese Bibliothek, die ich zur Optimierung meiner Expert Advisors verwende, grundlegend überarbeitet. Diese Version ist gestrafft, aber Sie können sie leicht um alltägliche Aufgaben erweitern, die Sie vielleicht automatisieren möchten. So könnten Sie z. B. Handelsbeschränkungen nach einer fehlgeschlagenen Prop-Firm-Challenge hinzufügen oder den Handel am Montag nach einer erfolgreichen oder fehlgeschlagenen Challenge wieder aufnehmen.

Alle Änderungen und Ergänzungen zu dieser Bibliothek sind am Ende des Codes aufgeführt. Dieses Framework ist flexibel und kann an Ihre spezifischen Bedürfnisse angepasst werden, sei es durch Hinzufügen einer komplexeren Logik für Handelsbeschränkungen, die Planung von Geschäften oder die Feinabstimmung der Leistung auf der Grundlage von Optimierungsergebnissen.

Fühlen Sie sich frei, es für Ihre Routineaufgaben weiter anzupassen!

Diese Bibliothek wurde für das Testen von Expert Advisors (EAs) in MetaTrader 5 entwickelt, mit besonderem Augenmerk auf die Anforderungen des Eigenhandels von Unternehmen. Das Ziel ist es, Handelsumgebungen zu simulieren, in denen der Händler bestimmte Gewinn- und Verlustschwellen erreichen muss, um die Herausforderung einer Firma zu bestehen. Der EA passt den Kontostand an, indem er ihn auf den Ausgangswert zurücksetzt, sobald bestimmte Gewinn- oder Verlustprozentsätze erreicht werden, und ahmt so die Regeln vieler Prop-Firmen nach.

Hier ist die vollständige Struktur für den Expert Advisor (EA), der die Bibliothek BalanceReset.mqh verwendet. Bei diesem Aufbau wird die Logik für das Zurücksetzen der Bilanz direkt in den EA integriert, wobei die saubere Trennung der Funktionen durch die #include-Anweisung beibehalten wird:

#include <BalanceReset.mqh>   // Einbindung der Bibliothek zum Zurücksetzen des Gleichgewichts

//+------------------------------------------------------------------+
//| Experten-Initialisierungsfunktion|
//+------------------------------------------------------------------+
int OnInit()
{
    InitBalance();  // Initialisieren der Startbilanz
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Experten-Tick-Funktion|
//+------------------------------------------------------------------+
void OnTick()
{
    CheckBalanceAndReset();  // Prüfen und Zurücksetzen des Saldos anhand von Schwellenwerten
}

//+------------------------------------------------------------------+
//| Experten-Deinitialisierungsfunktion|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    PrintBalanceResetResults();  // Ausgabe der Ergebnisse des Zurücksetzens der Waage in das Protokoll
}

Schlüssel-Funktionen

1. Einstellbare Schwellenwerte für Gewinn und Verlust

   • Die Bibliothek ermöglicht Ihnen die Anpassung der Gewinn- und Verlustschwellen, die während des Backtesting-Prozesses eine Rücksetzung der Bilanz auslösen. Diese Schwellenwerte können mithilfe von Eingabeparametern geändert werden, was die Anpassung der Testbedingungen erleichtert.

   Beispiel:

input double profit_threshold = 8.0;  // Gewinnschwelle, Standardwert ist 8%
input double loss_threshold = -6.0;   // Verlustschwelle, Standardwert ist -6%

2. Anfangsbestand Initialisierung

• Diese Funktion speichert den anfänglichen Kontostand zu Beginn des Tests. Sie wird nur beim ersten Tick ausgeführt, um den anfänglichen Startsaldo zu erfassen.

Beispiel:

void InitBalance()
{
    initial_balance = AccountInfoDouble(ACCOUNT_BALANCE);  // Speicherung des Anfangssaldos
}

3. die Logik der Waagenrückstellung

• Der Kern der Bibliothek vergleicht den aktuellen Saldo mit dem Anfangssaldo, um den Prozentsatz des Gewinns oder Verlusts zu berechnen. Überschreitet der Gewinn den angegebenen Schwellenwert (z. B. 8 %) oder der Verlust den Schwellenwert (z. B. -6 %), wird der Saldo auf den Anfangswert zurückgesetzt.
• Gewinn zurücksetzen: Mit der Funktion TesterWithdrawal wird der überschüssige Betrag abgezogen, um den Saldo wieder auf den Ausgangswert zu bringen, wenn die Gewinnschwelle erreicht ist.
• Verlust zurücksetzen: Mit der Funktion TesterEinzahlung wird der Saldo auf den Ausgangswert zurückgesetzt, wenn die Verlustschwelle erreicht ist.

Beispiel:

void CheckBalanceAndReset()
{
    double current_balance = AccountInfoDouble(ACCOUNT_BALANCE);
    if (initial_balance == 0) {
        initial_balance = current_balance; // Erster Tick, Speicherung des Anfangssaldos
    }
    double profit_percentage = (current_balance - initial_balance) / initial_balance * 100.0;

    if (profit_percentage >= profit_threshold) {
        double withdrawal_amount = current_balance - initial_balance;
        if (TesterWithdrawal(withdrawal_amount)) {
            successful_resets++;
            ArrayResize(reset_times, ArraySize(reset_times) + 1);
            reset_times[ArraySize(reset_times) - 1] = TimeCurrent();
            Print("Profit reached. Balance has been reset to the initial value.");
        }
    }

    if (profit_percentage <= loss_threshold) {
        double deposit_amount = initial_balance - current_balance;
        if (TesterDeposit(deposit_amount)) {
            unsuccessful_resets++;
            ArrayResize(reset_times, ArraySize(reset_times) + 1);
            reset_times[ArraySize(reset_times) - 1] = TimeCurrent();
            Print("Loss reached. Balance has been reset to the initial value.");
        }
    }
}

4. Ergebnisprotokollierung

• Nach Abschluss des Tests gibt diese Funktion die Anzahl der erfolgreichen Rücksetzungen (sowohl für Gewinn als auch für Verlust) und die Anzahl der Tage zwischen den einzelnen Rücksetzungen aus. Dies gibt Aufschluss darüber, wie häufig die Saldenrückstellungen während des Tests erfolgten.

Beispiel:

void PrintBalanceResetResults()
{
    PrintFormat("Number of successful profit resets: %d", successful_resets);
    PrintFormat("Number of successful loss resets: %d", unsuccessful_resets);
    
    for (int i = 1; i < ArraySize(reset_times); i++)
    {
        int days_between_resets = (reset_times[i] - reset_times[i-1]) / 86400; // 86400 Sekunden an einem Tag
        PrintFormat("Days between reset %d and reset %d: %d days", i, i + 1, days_between_resets);
    }
}

Schlussfolgerung

Diese Bibliothek hilft dabei, eine Handelsumgebung zu simulieren, die den üblichen Anforderungen von Eigenhandelsunternehmen entspricht. Durch das Zurücksetzen des Saldos, wenn vordefinierte Gewinn- und Verlustschwellen erreicht werden, können Händler ihre Strategien effektiver testen und die Leistung ihres EAs basierend auf den Regeln der Eigenhandelsfirma analysieren.

Beschreibung der Codeänderungen und -ergänzungen:

Der neue Code enthält mehrere Verbesserungen und Ergänzungen im Vergleich zum alten Code. Nachstehend finden Sie eine ausführliche Erläuterung der hinzugefügten und geänderten Elemente:

Neue Eingabeparameter:

• max_loss und min_won :

input double max_loss = 1;   // Maximaler Verlust
input double min_won = 1;    // Min gewonnen

Zweck: Mit diesen Eingabeparametern können Sie den maximal zulässigen Verlust ( max_loss ) und die Mindestanzahl der erforderlichen erfolgreichen Gewinnrücksetzungen ( min_won ) festlegen. Sie bieten mehr Kontrolle über die Optimierungsbedingungen.

Zusätzliche Variablen:

• reset_status[] :

string reset_status[]; // Array zum Speichern des Status jeder Rücksetzung

Zweck: Ein Array, das den Status ("Gewinn zurücksetzen" oder "Verlust zurücksetzen") jedes Rücksetzungsereignisses speichert.

stopOptimierung :

bool stopOptimization = false;

Zweck: Ein Flag, das anzeigt, wann die Optimierung unter bestimmten Bedingungen gestoppt werden sollte.

badResult :

bool badResult = false; // Flagge zur Anzeige eines schlechten Optimierungsergebnisses

Zweck: Ein Flag, um das Optimierungsergebnis als ungünstig zu kennzeichnen, das verwendet werden kann, um das Ergebnis in OnTester() zu beeinflussen.

Änderungen in CheckBalanceAndReset() :

• Aufzeichnung des Reset-Status:

ArrayResize(reset_status, ArraySize(reset_status) + 1); // Ändern Sie die Größe des Arrays, um den Rücksetzstatus zu erfassen
reset_status[ArraySize(reset_status) - 1] = "Profit reset"; // Aufzeichnung des Status

Zweck: Wenn ein Gewinn-Reset stattfindet, wird der Status im reset_status[]-Array aufgezeichnet.

Handhabung von Verlust-Rücksetzungen mit Optimierungsstopp-Bedingung:

if (TesterDeposit(deposit_amount))
{
    unsuccessful_resets++;  // Erhöhen Sie den Zähler für erfolglose Rücksetzungen von Verlusten
    // Zeit und Status der Rückstellung aufzeichnen
    ArrayResize(reset_status, ArraySize(reset_status) + 1);
    reset_status[ArraySize(reset_status) - 1] = "Loss reset";
    {
        stopOptimization = true;
        CheckStopCondition();  // Prüfen, ob die Optimierung beendet werden soll
    }
    PrintFormat("Loss reached. Balance has been reset to the initial value.");
}

Zweck: Nach einem Verlust-Reset erhöht der Code nun unsuccessful_resets , zeichnet den Status auf, setzt stopOptimization auf true und ruft CheckStopCondition() auf, um festzustellen, ob die Optimierung angehalten werden sollte.

Neue Funktion CheckStopCondition() :

void CheckStopCondition()
{
    if(stopOptimization)
    {
        Print("Stopping current optimization pass");
        badResult = true;  // Markieren Sie das Ergebnis als schlecht
        TesterStop();
    }
}

Zweck: Diese Funktion prüft, ob stopOptimization wahr ist, und wenn ja, markiert sie das Ergebnis als schlecht und stoppt den aktuellen Optimierungsdurchlauf mit TesterStop() .

Neue Funktion OnTester() :

double OnTester()
{
    // Wenn die Anzahl der erfolgreichen Rücksetzungen unter dem erforderlichen Minimum liegt oder badResult gesetzt ist
    if(successful_resets < min_won || badResult)
    {
        Print("Optimization failed: returning a highly unfavorable result.");
        // Rückgabe eines äußerst ungünstigen Ergebnisses, um den Optimierungsdurchgang zu verderben
        return -999999;
    }

    // Berechnung der Differenz zwischen erfolgreichen und erfolglosen Rücksetzungen
    int reset_difference = successful_resets - unsuccessful_resets;

    // Prüfen, ob die Differenz negativ ist
    if(reset_difference < 0)
    {
        Print("Negative difference between successful and unsuccessful resets. Returning a highly unfavorable result.");
        // Rückgabe eines sehr ungünstigen Ergebnisses, wenn die Differenz negativ ist
        return -999999;
    }

    // Ausgabe der Differenz in das Protokoll
    PrintFormat("Difference between successful and unsuccessful resets: %d", reset_difference);

    // Rückgabe der Differenz als Ergebnis des Testers
    return reset_difference;
}

Zweck: Diese Funktion liefert ein eigenes Kriterium für den Optimierungsprozess. Sie prüft, ob die Anzahl der erfolgreichen Rücksetzungen die Mindestanforderung erfüllt oder ob das Ergebnis schlecht ist. Sie berechnet die Differenz zwischen erfolgreichen und nicht erfolgreichen Rücksetzungen und gibt diesen Wert zurück, es sei denn, die Differenz ist negativ. In diesem Fall gibt sie ein sehr ungünstiges Ergebnis zurück, um den Optimierer zu beeinflussen.

Erweiterungen in PrintBalanceResetResults() :

// Ausgabe der Daten jeder Rückstellung und der Anzahl der dazwischen liegenden Tage
for(int i = 1; i < ArraySize(reset_times); i++)
{
    // Berechnen Sie die Anzahl der Tage zwischen den Rücksetzungen
    int days_between_resets = (reset_times[i] - reset_times[i-1]) / 86400; // 86400 Sekunden an einem Tag
    // Ausdrucken der Rücksetzdaten, des Status und der dazwischen liegenden Tage
    PrintFormat("Reset %d: %s (%s), Reset %d: %s (%s), Days between: %d days",
                i, TimeToString(reset_times[i-1], TIME_DATE), reset_status[i-1],
                i + 1, TimeToString(reset_times[i], TIME_DATE), reset_status[i],
                days_between_resets);
}

Zweck: Die Funktion gibt jetzt nicht nur die Anzahl der Rücksetzungen aus, sondern auch Einzelheiten zu jedem Rücksetzungsereignis, einschließlich Datum, Status und Anzahl der Tage zwischen den Rücksetzungen. Dadurch wird ein umfassenderes Protokoll der Rücksetzungsaktivitäten erstellt.

Initialisierung und Verwendung von Variablen:

• Initiale Saldenprüfung:

if(initial_balance == 0)
{
    initial_balance = current_balance;
}

Zweck: Stellt sicher, dass der initial_balance beim ersten Tick korrekt gesetzt ist.

Berechnung des Gewinnprozentsatzes:

double profit_percentage = (current_balance - initial_balance) / initial_balance * 100.0;

Zweck: Berechnet den Gewinn- oder Verlustprozentsatz in Bezug auf den Anfangssaldo.

Zusammenfassung der Hinzufügungen:

• Kontrolle über den Optimierungsprozess:

  • Der Code enthält jetzt Mechanismen, um den Optimierungsprozess auf der Grundlage bestimmter Bedingungen zu stoppen, z. B. wenn die maximale Anzahl erfolgloser Rücksetzungen überschritten oder die Mindestanzahl erfolgreicher Rücksetzungen nicht erreicht wird.

• Verbesserte Protokollierung und Nachverfolgung:

  • Die Hinzufügung von reset_status[] und die detaillierte Protokollierung in PrintBalanceResetResults() ermöglicht eine bessere Nachverfolgung von Reset-Ereignissen und deren Ergebnissen.

• Integration mit Optimizer über OnTester() :

  • Durch die Implementierung von OnTester() kann das Skript Ergebnisse an die Optimierungs-Engine zurückmelden und so die Auswahl von Parametersätzen auf der Grundlage von benutzerdefinierten Kriterien beeinflussen.

Diese Änderungen erweitern die Funktionalität des Skripts, indem sie eine bessere Kontrolle über die Handelsoperationen während der Optimierung, eine detailliertere Protokollierung von Ereignissen und die Möglichkeit zur Beeinflussung des Optimierungsprozesses auf der Grundlage von benutzerdefinierten Kriterien bieten.