Balance_Reset - biblioteca para MetaTrader 5

Atualizar:

Fiz uma atualização significativa dessa biblioteca, que uso para otimizar meus consultores especializados. Esta versão é simplificada, mas você pode ampliá-la facilmente para incluir tarefas cotidianas que talvez queira automatizar. Por exemplo, você poderia adicionar restrições à negociação após um desafio fracassado da prop firm ou retomar a negociação na segunda-feira após um desafio bem-sucedido ou fracassado.

Todas as alterações e adições a essa biblioteca estão descritas no final do código. Essa estrutura é flexível e pode ser adaptada às suas necessidades específicas, seja adicionando uma lógica mais complexa para restrições de negociação, agendamento de negociações ou ajuste fino do desempenho com base nos resultados da otimização.

Sinta-se à vontade para personalizá-lo ainda mais para suas tarefas rotineiras!

Essa biblioteca foi projetada para testar Expert Advisors (EAs) no MetaTrader 5 com foco específico nos requisitos de negociação de empresas proprietárias. O objetivo é simular ambientes de negociação em que o trader deve atingir determinados limites de lucros e perdas para passar no desafio de uma empresa. O EA ajusta o saldo da conta, redefinindo-o para o valor inicial sempre que as porcentagens de lucro ou perda especificadas são atingidas, imitando as regras de muitas firmas de propósitos.

Aqui está a estrutura completa do Expert Advisor (EA) usando a biblioteca BalanceReset.mqh. Essa configuração integra a lógica de redefinição de saldo diretamente no EA e, ao mesmo tempo, mantém uma separação clara das funções por meio da diretiva #include:

#include <BalanceReset.mqh>   // Incluir a biblioteca de redefinição de saldo

//+------------------------------------------------------------------+
//| Função de inicialização especializada|
//+------------------------------------------------------------------+
int OnInit()
{
    InitBalance();  // Inicializar o saldo inicial
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Função de tique de especialista|
//+------------------------------------------------------------------+
void OnTick()
{
    CheckBalanceAndReset();  // Verificar e redefinir o saldo com base em limites
}

//+------------------------------------------------------------------+
//| Função de desinicialização de especialista|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    PrintBalanceResetResults();  // Resultados da redefinição do saldo de saída para o registro
}

Funções-chave

1. Limites ajustáveis de lucros e perdas

   • A biblioteca permite que você ajuste os limites de lucros e perdas que acionam as redefinições de saldo durante o processo de backtesting. Esses limites podem ser alterados usando parâmetros de entrada, o que facilita a personalização das condições de teste.

   Exemplo:

input double profit_threshold = 8.0;  // Limite de lucro, o padrão é 8%
input double loss_threshold = -6.0;   // Limite de perda, o padrão é -6%

2. Inicialização do saldo inicial

• Essa função armazena o saldo inicial da conta no início do teste. Ela é executada somente no primeiro tique para capturar o saldo inicial.

Exemplo:

void InitBalance()
{
    initial_balance = AccountInfoDouble(ACCOUNT_BALANCE);  // Armazenamento do saldo inicial
}

3. lógica de reinicialização do balanço

• O núcleo da biblioteca verifica o saldo atual em relação ao saldo inicial para calcular a porcentagem de lucro ou perda. Se o lucro exceder o limite especificado (por exemplo, 8%) ou a perda exceder seu limite (por exemplo, -6%), o saldo será redefinido para o valor inicial.
• Reinicialização do lucro: A função TesterWithdrawal é usada para retirar o valor excedente para trazer o saldo de volta ao valor inicial quando o limite de lucro é atingido.
• Redefinição de perdas: A função TesterDeposit restaura o saldo para o valor inicial quando o limite de perda é acionado.

Exemplo:

void CheckBalanceAndReset()
{
    double current_balance = AccountInfoDouble(ACCOUNT_BALANCE);
    if (initial_balance == 0) {
        initial_balance = current_balance; // Primeiro tick, armazena o saldo inicial
    }
    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. Registro de resultados

• Após a conclusão do teste, essa função gera o número de redefinições bem-sucedidas (para lucros e perdas) e o número de dias entre cada redefinição. Isso fornece informações sobre a frequência com que as redefinições de saldo ocorreram durante o teste.

Exemplo:

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 segundos em um dia
        PrintFormat("Days between reset %d and reset %d: %d days", i, i + 1, days_between_resets);
    }
}

Conclusão

Essa biblioteca ajuda a simular um ambiente de negociação que segue os requisitos comuns das firmas de negociação proprietárias. Ao redefinir o saldo quando os limites predefinidos de lucros e perdas são atingidos, ela permite que os traders testem suas estratégias com mais eficiência e analisem o desempenho de seu EA com base nas regras da firma proprietária.

Descrição das alterações e adições de código:

O novo código inclui vários aprimoramentos e adições em comparação com o código antigo. Abaixo está uma explicação detalhada do que foi adicionado e modificado:

Novos parâmetros de entrada:

• max_loss e min_won :

input double max_loss = 1;   // Perda máxima
input double min_won = 1;    // Mínimo ganho

Objetivo: Esses parâmetros de entrada permitem que você defina a perda máxima permitida ( max_loss ) e o número mínimo de redefinições de lucro bem-sucedidas necessárias ( min_won ). Eles oferecem mais controle sobre as condições de otimização.

Variáveis adicionais:

• reset_status[] :

string reset_status[]; // Matriz para armazenar o status de cada reinicialização

Finalidade: Uma matriz adicionada para armazenar o status ("Reinicialização de lucros" ou "Reinicialização de perdas") de cada evento de reinicialização de saldo.

stopOptimization :

bool stopOptimization = false;

Objetivo: Um sinalizador usado para indicar quando a otimização deve ser interrompida com base em determinadas condições.

badResult :

bool badResult = false; // Sinalizador para indicar um resultado de otimização ruim

Propósito: Um sinalizador para marcar o resultado da otimização como desfavorável, que pode ser usado para influenciar o resultado em OnTester() .

Modificações em CheckBalanceAndReset() :

• Registro do status de redefinição:

ArrayResize(reset_status, ArraySize(reset_status) + 1); // Redimensione a matriz para registrar o status da redefinição
reset_status[ArraySize(reset_status) - 1] = "Profit reset"; // Registre o status

Objetivo: Quando ocorre uma redefinição de lucro, o status é registrado na matriz reset_status[].

Tratamento de redefinições de perdas com condição de parada de otimização:

if (TesterDeposit(deposit_amount))
{
    unsuccessful_resets++;  // Aumentar o contador para redefinições de perda malsucedidas
    // Registre a hora e o status da redefinição
    ArrayResize(reset_status, ArraySize(reset_status) + 1);
    reset_status[ArraySize(reset_status) - 1] = "Loss reset";
    {
        stopOptimization = true;
        CheckStopCondition();  // Verificar se a otimização deve ser interrompida
    }
    PrintFormat("Loss reached. Balance has been reset to the initial value.");
}

Objetivo: após uma redefinição de perda, o código agora incrementa unsuccessful_resets , registra o status, define stopOptimization como true e chama CheckStopCondition() para determinar se a otimização deve ser interrompida.

Nova função CheckStopCondition() :

void CheckStopCondition()
{
    if(stopOptimization)
    {
        Print("Stopping current optimization pass");
        badResult = true;  // Marcar o resultado como ruim
        TesterStop();
    }
}

Objetivo: Esta função verifica se stopOptimization é verdadeiro e, se for, marca o resultado como ruim e interrompe a passagem de otimização atual usando TesterStop() .

Nova função OnTester() :

double OnTester()
{
    // Se o número de reinicializações bem-sucedidas for menor que o mínimo necessário ou se badResult for definido
    if(successful_resets < min_won || badResult)
    {
        Print("Optimization failed: returning a highly unfavorable result.");
        // Retornar um resultado altamente desfavorável para estragar o passe de otimização
        return -999999;
    }

    // Calcular a diferença entre as reinicializações bem-sucedidas e as malsucedidas
    int reset_difference = successful_resets - unsuccessful_resets;

    // Verificar se a diferença é negativa
    if(reset_difference < 0)
    {
        Print("Negative difference between successful and unsuccessful resets. Returning a highly unfavorable result.");
        // Retornar um resultado altamente desfavorável se a diferença for negativa
        return -999999;
    }

    // Emite a diferença para o registro
    PrintFormat("Difference between successful and unsuccessful resets: %d", reset_difference);

    // Retornar a diferença como o resultado do testador
    return reset_difference;
}

Objetivo: Esta função fornece um critério personalizado para o processo de otimização. Ela verifica se o número de reinicializações bem-sucedidas atende ao requisito mínimo ou se o resultado é ruim. Ela calcula a diferença entre as reinicializações bem-sucedidas e as malsucedidas e retorna esse valor, a menos que a diferença seja negativa, caso em que retorna um resultado altamente desfavorável para influenciar o otimizador.

Aprimoramentos em PrintBalanceResetResults() :

// Emite as datas de cada reinicialização e o número de dias entre elas
for(int i = 1; i < ArraySize(reset_times); i++)
{
    // Calcular o número de dias entre as reinicializações
    int days_between_resets = (reset_times[i] - reset_times[i-1]) / 86400; // 86400 segundos em um dia
    // Imprimir as datas de reinicialização, o status e os dias entre elas
    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);
}

Objetivo: A função agora não apenas gera o número de reinicializações, mas também detalha cada evento de reinicialização, incluindo a data, o status e o número de dias entre as reinicializações. Isso fornece um registro mais abrangente das atividades de redefinição.

Inicialização e uso de variáveis:

• Verificação inicial de saldo:

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

Objetivo: Garante que o initial_balance seja definido corretamente no primeiro tick.

Cálculo da porcentagem de lucro:

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

Objetivo: calcula a porcentagem de lucro ou perda em relação ao saldo inicial.

Resumo das adições:

• Controle sobre o processo de otimização:

  • O código agora inclui mecanismos para interromper o processo de otimização com base em condições específicas, como exceder o número máximo de reinicializações malsucedidas ou não atingir o número mínimo de reinicializações bem-sucedidas.

• Registro e rastreamento aprimorados:

  • A adição de reset_status[] e o registro detalhado em PrintBalanceResetResults() permitem um melhor acompanhamento dos eventos de redefinição e seus resultados.

• Integração com o Optimizer via OnTester() :

  • Ao implementar OnTester(), o script pode comunicar os resultados de volta ao mecanismo de otimização, influenciando a seleção de conjuntos de parâmetros com base em critérios personalizados.

Essas alterações aprimoram a funcionalidade do script, proporcionando melhor controle sobre as operações de negociação durante a otimização, registro mais detalhado de eventos e a capacidade de influenciar o processo de otimização com base em critérios personalizados.