Balance_Reset - bibliothèque pour MetaTrader 5

Mise à jour :

J'ai effectué une mise à jour importante de cette bibliothèque, que j'utilise pour optimiser mes conseillers experts. Cette version est simplifiée, mais vous pouvez facilement l'étendre pour inclure des tâches quotidiennes que vous pourriez vouloir automatiser. Par exemple, vous pouvez ajouter des restrictions sur les transactions après l'échec d'un défi de société de conseil ou reprendre les transactions le lundi après un défi réussi ou échoué.

Tous les changements et ajouts apportés à cette bibliothèque sont décrits à la fin du code. Ce cadre est flexible et peut être adapté à vos besoins spécifiques, qu'il s'agisse d'ajouter une logique plus complexe pour les restrictions de trading, de planifier les transactions ou d'affiner les performances en fonction des résultats de l'optimisation.

N'hésitez pas à le personnaliser davantage pour vos tâches de routine !

Cette bibliothèque est conçue pour tester les Expert Advisors (EA) dans MetaTrader 5 avec un accent particulier sur les exigences de trading des entreprises propriétaires. L'objectif est de simuler des environnements de trading où le trader doit atteindre certains seuils de profit et de perte pour réussir le challenge de la société. L'EA ajuste le solde du compte en le réinitialisant à sa valeur initiale chaque fois que les pourcentages de profit ou de perte spécifiés sont atteints, imitant ainsi les règles de nombreuses sociétés d'investissement.

Voici la structure complète de l'Expert Advisor (EA) utilisant la bibliothèque BalanceReset.mqh. Cette configuration intègre la logique de réinitialisation de la balance directement dans l'EA tout en maintenant une séparation nette des fonctions grâce à la directive #include:

#include <BalanceReset.mqh>   // Inclure la bibliothèque de réinitialisation de l'équilibre

//+------------------------------------------------------------------+
//| Fonction d'initialisation de l'expert|
//+------------------------------------------------------------------+
int OnInit()
{
    InitBalance();  // Initialiser la balance de départ
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Fonction de tic-tac expert|
//+------------------------------------------------------------------+
void OnTick()
{
    CheckBalanceAndReset();  // Vérifier et réinitialiser l'équilibre en fonction de seuils
}

//+------------------------------------------------------------------+
//| Fonction de désinitialisation de l'expert|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    PrintBalanceResetResults();  // Affichage des résultats de la réinitialisation de la balance dans le journal
}

Fonctions clés

1. Seuils de pertes et profits ajustables

   • La bibliothèque vous permet d'ajuster les seuils de profit et de perte qui déclenchent les réinitialisations de solde pendant le processus de backtesting. Ces seuils peuvent être modifiés à l'aide de paramètres d'entrée, ce qui facilite la personnalisation des conditions de test.

   Exemple :

input double profit_threshold = 8.0;  // Seuil de rentabilité, la valeur par défaut est de 8 %.
input double loss_threshold = -6.0;   // Seuil de perte, la valeur par défaut est de -6%.

2. Solde initial Initialisation

• Cette fonction enregistre le solde initial du compte au début du test. Elle ne s'exécute qu'au premier tick pour capturer le solde initial.

Exemple :

void InitBalance()
{
    initial_balance = AccountInfoDouble(ACCOUNT_BALANCE);  // Stockage du solde initial
}

3. logique de réinitialisation de la balance

• Le cœur de la bibliothèque compare le solde actuel au solde initial pour calculer le pourcentage de profit ou de perte. Si le bénéfice dépasse le seuil spécifié (par exemple, 8 %) ou si la perte dépasse son seuil (par exemple, -6 %), le solde est réinitialisé à la valeur initiale.
• Réinitialisation du profit : La fonction TesterWithdrawal est utilisée pour retirer le montant excédentaire afin de ramener le solde à sa valeur initiale lorsque le seuil de profit est atteint.
• Remise à zéro des pertes : La fonction TesterDeposit permet de rétablir le solde à sa valeur initiale lorsque le seuil de perte est déclenché.

Exemple :

void CheckBalanceAndReset()
{
    double current_balance = AccountInfoDouble(ACCOUNT_BALANCE);
    if (initial_balance == 0) {
        initial_balance = current_balance; // Premier tic-tac, stocker le solde initial
    }
    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. Enregistrement des résultats

• Une fois le test terminé, cette fonction indique le nombre de réinitialisations réussies (pour les bénéfices et les pertes) et le nombre de jours entre chaque réinitialisation. Cela permet de savoir à quelle fréquence les remises à zéro des soldes se sont produites pendant le test.

Exemple :

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 secondes en un jour
        PrintFormat("Days between reset %d and reset %d: %d days", i, i + 1, days_between_resets);
    }
}

Conclusion

Cette bibliothèque permet de simuler un environnement de trading qui adhère aux exigences communes des sociétés de trading. En réinitialisant le solde lorsque des seuils de profit et de perte prédéfinis sont atteints, elle permet aux traders de tester leurs stratégies plus efficacement et d'analyser les performances de leur EA en fonction des règles de la société de courtage.

Description des modifications et ajouts au code :

Le nouveau code comprend plusieurs améliorations et ajouts par rapport à l'ancien code. Vous trouverez ci-dessous une explication détaillée de ce qui a été ajouté et modifié :

Nouveaux paramètres d'entrée :

• max_loss et min_won :

input double max_loss = 1;   // Perte maximale
input double min_won = 1;    // Min gagné

Objectif : Ces paramètres d'entrée vous permettent de définir la perte maximale autorisée ( max_loss ) et le nombre minimum de réinitialisations de bénéfices réussies ( min_won ). Ils permettent de mieux contrôler les conditions d'optimisation.

Variables supplémentaires :

• reset_status[] :

string reset_status[]; // Tableau pour stocker l'état de chaque réinitialisation

Objet : Tableau ajouté pour stocker l'état ("Réinitialisation des bénéfices" ou "Réinitialisation des pertes") de chaque événement de réinitialisation de la balance.

stopOptimisation :

bool stopOptimization = false;

Objet : Un drapeau utilisé pour indiquer quand l'optimisation doit être arrêtée en fonction de certaines conditions.

badResult :

bool badResult = false; // Drapeau indiquant un mauvais résultat d'optimisation

Objectif : Un indicateur pour marquer le résultat de l'optimisation comme défavorable, qui peut être utilisé pour influencer le résultat dans OnTester() .

Modifications dans CheckBalanceAndReset() :

• Enregistrement du statut de réinitialisation :

ArrayResize(reset_status, ArraySize(reset_status) + 1); // Redimensionner le tableau pour enregistrer l'état de la réinitialisation
reset_status[ArraySize(reset_status) - 1] = "Profit reset"; // Enregistrer l'état

Objectif : Lorsqu'une réinitialisation des bénéfices se produit, le statut est enregistré dans le tableau reset_status[].

Gestion des réinitialisations de pertes avec condition d'arrêt de l'optimisation :

if (TesterDeposit(deposit_amount))
{
    unsuccessful_resets++;  // Augmenter le compteur pour les réinitialisations de perte infructueuses
    // Enregistrer l'heure et l'état de la réinitialisation
    ArrayResize(reset_status, ArraySize(reset_status) + 1);
    reset_status[ArraySize(reset_status) - 1] = "Loss reset";
    {
        stopOptimization = true;
        CheckStopCondition();  // Vérifier si l'optimisation doit être arrêtée
    }
    PrintFormat("Loss reached. Balance has been reset to the initial value.");
}

Objet : Après une réinitialisation des pertes, le code incrémente unsuccessful_resets, enregistre l'état, attribue la valeur true à stopOptimization et appelle CheckStopCondition() pour déterminer si l'optimisation doit être interrompue.

Nouvelle fonction CheckStopCondition() :

void CheckStopCondition()
{
    if(stopOptimization)
    {
        Print("Stopping current optimization pass");
        badResult = true;  // Marquer le résultat comme mauvais
        TesterStop();
    }
}

Objectif : Cette fonction vérifie si stopOptimization est vrai et, si c'est le cas, marque le résultat comme mauvais et arrête la passe d'optimisation en cours à l'aide de TesterStop() .

Nouvelle fonction OnTester() :

double OnTester()
{
    // Si le nombre de réinitialisations réussies est inférieur au minimum requis ou si badResult est défini.
    if(successful_resets < min_won || badResult)
    {
        Print("Optimization failed: returning a highly unfavorable result.");
        // Renvoyer un résultat très défavorable pour gâcher la passe d'optimisation
        return -999999;
    }

    // Calculer la différence entre les réinitialisations réussies et les réinitialisations ratées
    int reset_difference = successful_resets - unsuccessful_resets;

    // Vérifier si la différence est négative
    if(reset_difference < 0)
    {
        Print("Negative difference between successful and unsuccessful resets. Returning a highly unfavorable result.");
        // Renvoie un résultat très défavorable si la différence est négative
        return -999999;
    }

    // Affichage de la différence dans le journal
    PrintFormat("Difference between successful and unsuccessful resets: %d", reset_difference);

    // Renvoyer la différence comme résultat du testeur
    return reset_difference;
}

Objectif : cette fonction fournit un critère personnalisé pour le processus d'optimisation. Elle vérifie si le nombre de réinitialisations réussies répond aux exigences minimales ou si le résultat est mauvais. Elle calcule la différence entre les réinitialisations réussies et les réinitialisations infructueuses et renvoie cette valeur, sauf si la différence est négative, auquel cas elle renvoie un résultat très défavorable pour influencer l'optimiseur.

Améliorations apportées à PrintBalanceResetResults() :

// Affiche les dates de chaque réinitialisation et le nombre de jours qui les séparent.
for(int i = 1; i < ArraySize(reset_times); i++)
{
    // Calculer le nombre de jours entre les réinitialisations
    int days_between_resets = (reset_times[i] - reset_times[i-1]) / 86400; // 86400 secondes en un jour
    // Imprimer les dates de réinitialisation, l'état et les jours qui les séparent.
    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);
}

Objectif : La fonction affiche désormais non seulement le nombre de réinitialisations, mais aussi le détail de chaque événement de réinitialisation, y compris la date, l'état et le nombre de jours entre les réinitialisations. Cela permet d'obtenir un journal plus complet des activités de réinitialisation.

Initialisation et utilisation des variables :

• Vérification initiale de l'équilibre :

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

Objectif : S'assurer que le solde initial (initial_balance) est correctement défini lors du premier tick.

Calcul du pourcentage de profit :

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

Objectif : Calcule le pourcentage de profit ou de perte par rapport au solde initial.

Résumé des ajouts :

• Contrôle du processus d'optimisation :

  • Le code comprend désormais des mécanismes permettant d'arrêter le processus d'optimisation en fonction de conditions spécifiques, telles que le dépassement du nombre maximal de réinitialisations infructueuses ou le fait de ne pas atteindre le nombre minimal de réinitialisations réussies.

• Amélioration de la journalisation et du suivi :

  • L'ajout de reset_status[] et d'une journalisation détaillée dans PrintBalanceResetResults() permet un meilleur suivi des événements de réinitialisation et de leurs résultats.

• Intégration avec Optimizer via OnTester() :

  • En implémentant OnTester() , le script peut communiquer les résultats au moteur d'optimisation, influençant la sélection des ensembles de paramètres sur la base de critères personnalisés.

Ces changements améliorent la fonctionnalité du script en offrant un meilleur contrôle sur les opérations de trading pendant l'optimisation, une journalisation plus détaillée des événements et la possibilité d'influencer le processus d'optimisation sur la base de critères personnalisés.