Balance_Reset - libreria per MetaTrader 5

Aggiornamento:

Ho apportato un aggiornamento significativo a questa libreria, che utilizzo per ottimizzare i miei expert advisor. Questa versione è semplificata, ma si può facilmente estendere per includere le attività quotidiane che si desidera automatizzare. Ad esempio, si possono aggiungere restrizioni al trading dopo una sfida fallita con una società di prop o riprendere il trading il lunedì dopo una sfida riuscita o fallita.

Tutte le modifiche e le aggiunte a questa libreria sono descritte alla fine del codice. Questo framework è flessibile e può essere adattato alle vostre esigenze specifiche, sia che si tratti di aggiungere una logica più complessa per le restrizioni al trading, sia che si tratti di programmare le operazioni o di perfezionare le prestazioni in base ai risultati dell'ottimizzazione.

Sentitevi liberi di personalizzarlo ulteriormente per le vostre attività di routine!

Questa libreria è stata progettata per testare gli Expert Advisor (EA) in MetaTrader 5, con un'attenzione specifica ai requisiti di trading delle aziende proprietarie. L'obiettivo è quello di simulare ambienti di trading in cui il trader deve raggiungere determinate soglie di profitto e di perdita per superare la sfida dell'azienda. L'EA regola il saldo del conto riportandolo al valore iniziale ogni volta che vengono raggiunte le percentuali di profitto o di perdita specificate, imitando le regole di molte società di prop.

Ecco la struttura completa dell'Expert Advisor (EA) che utilizza la libreria BalanceReset.mqh. Questa configurazione integra la logica di azzeramento del saldo direttamente nell'EA, mantenendo una separazione netta delle funzioni grazie alla direttiva #include:

#include <BalanceReset.mqh>   // Includere la libreria di ripristino dell'equilibrio

//+------------------------------------------------------------------+
//| Funzione di inizializzazione dell'esperto|
//+------------------------------------------------------------------+
int OnInit()
{
    InitBalance();  // Inizializza il bilancio iniziale
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Funzione tick dell'esperto|
//+------------------------------------------------------------------+
void OnTick()
{
    CheckBalanceAndReset();  // Verifica e ripristino dell'equilibrio in base alle soglie
}

//+------------------------------------------------------------------+
//| Funzione di deinizializzazione dell'esperto|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    PrintBalanceResetResults();  // Emettere i risultati dell'azzeramento del bilanciamento nel log
}

Funzioni chiave

1. Soglie di profitto e di perdita regolabili

   • La libreria consente di regolare le soglie di profitto e di perdita che attivano l'azzeramento del saldo durante il processo di backtesting. Queste soglie possono essere modificate utilizzando i parametri di input, il che facilita la personalizzazione delle condizioni di test.

   Esempio:

input double profit_threshold = 8.0;  // Soglia di profitto, l'impostazione predefinita è 8%
input double loss_threshold = -6.0;   // Soglia di perdita, il valore predefinito è -6%.

2. Bilanciamento iniziale Inizializzazione

• Questa funzione memorizza il saldo iniziale del conto all'inizio del test. Viene eseguita solo al primo tick per acquisire il saldo iniziale.

Esempio:

void InitBalance()
{
    initial_balance = AccountInfoDouble(ACCOUNT_BALANCE);  // Memorizzazione del saldo iniziale
}

3. Logica di azzeramento della bilancia

• Il nucleo della libreria verifica il saldo corrente rispetto al saldo iniziale per calcolare la percentuale di profitto o di perdita. Se il profitto supera la soglia specificata (ad esempio, 8%) o la perdita supera la soglia (ad esempio, -6%), il saldo viene ripristinato al valore iniziale.
• Azzeramento del profitto: La funzione TesterWithdrawal viene utilizzata per prelevare l'importo in eccesso e riportare il saldo al valore iniziale quando viene raggiunta la soglia di profitto.
• Azzeramento delle perdite: La funzione TesterDeposit ripristina il saldo al valore iniziale quando viene attivata la soglia di perdita.

Esempio:

void CheckBalanceAndReset()
{
    double current_balance = AccountInfoDouble(ACCOUNT_BALANCE);
    if (initial_balance == 0) {
        initial_balance = current_balance; // Primo tick, memorizzare il saldo iniziale
    }
    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. Registrazione dei risultati

• Al termine del test, questa funzione fornisce il numero di azzeramenti riusciti (sia per i profitti che per le perdite) e il numero di giorni che intercorrono tra un azzeramento e l'altro. Questo fornisce indicazioni sulla frequenza degli azzeramenti del bilancio durante il test.

Esempio:

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

Conclusione

Questa libreria aiuta a simulare un ambiente di trading che aderisce ai requisiti comuni delle società di trading proprietarie. Azzerando il saldo quando vengono raggiunte le soglie di profitto e di perdita predefinite, consente ai trader di testare le proprie strategie in modo più efficace e di analizzare le prestazioni del proprio EA in base alle regole della società di prop.

Descrizione delle modifiche e delle aggiunte al codice:

Il nuovo codice include diversi miglioramenti e aggiunte rispetto al vecchio codice. Di seguito è riportata una spiegazione dettagliata di ciò che è stato aggiunto e modificato:

Nuovi parametri di ingresso:

• max_loss e min_won :

input double max_loss = 1;   // Perdita massima
input double min_won = 1;    // Min vinto

Scopo: Questi parametri di input consentono di impostare la perdita massima consentita ( max_loss ) e il numero minimo di ripristini del profitto richiesti ( min_won ). Forniscono un maggiore controllo sulle condizioni di ottimizzazione.

Variabili aggiuntive:

• reset_status[] :

string reset_status[]; // Array per memorizzare lo stato di ogni reset

Scopo: un array aggiunto per memorizzare lo stato ("Azzeramento profitti" o "Azzeramento perdite") di ogni evento di azzeramento del bilancio.

stopOttimizzazione :

bool stopOptimization = false;

Scopo: un flag utilizzato per indicare quando l'ottimizzazione deve essere interrotta in base a determinate condizioni.

badResult :

bool badResult = false; // Flag per indicare un cattivo risultato dell'ottimizzazione

Scopo: Un flag per contrassegnare il risultato dell'ottimizzazione come sfavorevole, che può essere utilizzato per influenzare il risultato in OnTester() .

Modifiche in CheckBalanceAndReset() :

• Registrazione dello stato di reset:

ArrayResize(reset_status, ArraySize(reset_status) + 1); // Ridimensionare l'array per registrare lo stato di reset
reset_status[ArraySize(reset_status) - 1] = "Profit reset"; // Registra lo stato

Scopo: Quando si verifica un azzeramento dei profitti, lo stato viene registrato nell'array reset_status[].

Gestione degli azzeramenti delle perdite con la condizione di stop dell'ottimizzazione:

if (TesterDeposit(deposit_amount))
{
    unsuccessful_resets++;  // Aumenta il contatore per i ripristini di perdita non andati a buon fine
    // Registrare l'ora e lo stato del reset
    ArrayResize(reset_status, ArraySize(reset_status) + 1);
    reset_status[ArraySize(reset_status) - 1] = "Loss reset";
    {
        stopOptimization = true;
        CheckStopCondition();  // Verificare se l'ottimizzazione deve essere interrotta
    }
    PrintFormat("Loss reached. Balance has been reset to the initial value.");
}

Scopo: Dopo un azzeramento delle perdite, il codice ora incrementa unsuccessful_reset, registra lo stato, imposta stopOptimization su true e chiama CheckStopCondition() per determinare se l'ottimizzazione deve essere interrotta.

Nuova funzione CheckStopCondition() :

void CheckStopCondition()
{
    if(stopOptimization)
    {
        Print("Stopping current optimization pass");
        badResult = true;  // Contrassegnare il risultato come negativo
        TesterStop();
    }
}

Scopo: Questa funzione controlla se stopOptimization è vero e, in tal caso, contrassegna il risultato come negativo e arresta il passaggio di ottimizzazione corrente utilizzando TesterStop() .

Nuova funzione OnTester() :

double OnTester()
{
    // Se il numero di ripristini riusciti è inferiore al minimo richiesto o se è impostato badResult
    if(successful_resets < min_won || badResult)
    {
        Print("Optimization failed: returning a highly unfavorable result.");
        // Restituire un risultato altamente sfavorevole per rovinare il passaggio di ottimizzazione
        return -999999;
    }

    // Calcolo della differenza tra i reset riusciti e quelli non riusciti
    int reset_difference = successful_resets - unsuccessful_resets;

    // Controllare se la differenza è negativa
    if(reset_difference < 0)
    {
        Print("Negative difference between successful and unsuccessful resets. Returning a highly unfavorable result.");
        // Restituisce un risultato altamente sfavorevole se la differenza è negativa
        return -999999;
    }

    // Emettere la differenza nel log
    PrintFormat("Difference between successful and unsuccessful resets: %d", reset_difference);

    // Restituzione della differenza come risultato del tester
    return reset_difference;
}

Scopo: Questa funzione fornisce un criterio personalizzato per il processo di ottimizzazione. Verifica se il numero di ripristini riusciti soddisfa il requisito minimo o se il risultato è negativo. Calcola la differenza tra i ripristini riusciti e quelli non riusciti e restituisce questo valore, a meno che la differenza non sia negativa, nel qual caso restituisce un risultato altamente sfavorevole per influenzare l'ottimizzatore.

Miglioramenti in PrintBalanceResetResults() :

// Emettere le date di ogni azzeramento e il numero di giorni che le separano.
for(int i = 1; i < ArraySize(reset_times); i++)
{
    // Calcolare il numero di giorni che intercorrono tra un reset e l'altro
    int days_between_resets = (reset_times[i] - reset_times[i-1]) / 86400; // 86400 secondi in un giorno
    // Stampa le date di reset, lo stato e i giorni che li separano.
    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);
}

Scopo: La funzione ora non solo fornisce il numero di azzeramenti, ma anche i dettagli di ogni evento di azzeramento, compresi la data, lo stato e il numero di giorni tra gli azzeramenti. In questo modo si ottiene un registro più completo delle attività di ripristino.

Inizializzazione e uso delle variabili:

• Controllo iniziale del bilancio:

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

Scopo: Assicura che il bilancio iniziale sia impostato correttamente al primo tick.

Calcolo della percentuale di profitto:

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

Scopo: calcola la percentuale di profitto o di perdita rispetto al saldo iniziale.

Riepilogo delle aggiunte:

• Controllo del processo di ottimizzazione:

  • Il codice include ora meccanismi per interrompere il processo di ottimizzazione in base a condizioni specifiche, come il superamento del numero massimo di ripristini non riusciti o il mancato raggiungimento del numero minimo di ripristini riusciti.

• Miglioramento della registrazione e della tracciabilità:

  • L'aggiunta di reset_status[] e di una registrazione dettagliata in PrintBalanceResetResults() consente di monitorare meglio gli eventi di reset e i loro risultati.

• Integrazione con Optimizer tramite OnTester() :

  • Implementando OnTester(), lo script può comunicare i risultati al motore di ottimizzazione, influenzando la selezione dei set di parametri in base a criteri personalizzati.

Queste modifiche migliorano la funzionalità dello script, fornendo un migliore controllo sulle operazioni di trading durante l'ottimizzazione, una registrazione più dettagliata degli eventi e la possibilità di influenzare il processo di ottimizzazione in base a criteri definiti su misura.