Balance_Reset - librería para MetaTrader 5

Actualización:

He hecho una actualización significativa de esta biblioteca, que utilizo para optimizar mis asesores expertos. Esta versión es simplificada, pero se puede ampliar fácilmente para incluir tareas cotidianas es posible que desee automatizar. Por ejemplo, usted podría agregar restricciones en el comercio después de un desafío fallido firma prop o reanudar el comercio el lunes después de un desafío exitoso o fallido.

Todos los cambios y adiciones a esta biblioteca se describen al final del código. Este marco es flexible y se puede adaptar a sus necesidades específicas, ya sea añadiendo una lógica más compleja para las restricciones de negociación, la programación de las operaciones, o el ajuste fino de rendimiento basado en los resultados de optimización.

Siéntete libre de personalizarlo aún más para tus tareas rutinarias.

Esta biblioteca está diseñada para probar Asesores Expertos (EAs) en MetaTrader 5 con un enfoque específico en los requisitos de comercio de la empresa propietaria. El objetivo es simular entornos de negociación donde el operador debe cumplir con ciertos umbrales de ganancias y pérdidas para pasar el desafío de una empresa. El EA ajusta el saldo de la cuenta restableciéndolo al valor inicial cada vez que se alcanzan los porcentajes especificados de ganancias o pérdidas, imitando las reglas de muchas empresas de prop.

Aquí está la estructura completa para el Asesor Experto (EA) utilizando la biblioteca BalanceReset.mqh. Esta configuración integra la lógica de restablecimiento de balance directamente en el EA, manteniendo una separación limpia de las funciones a través de la directiva #include:

#include <BalanceReset.mqh>   // Incluir la biblioteca de restablecimiento de saldo

//+------------------------------------------------------------------+
//| Función de inicialización experta|
//+------------------------------------------------------------------+
int OnInit()
{
    InitBalance();  // Inicializar el saldo inicial
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Función tick experto|
//+------------------------------------------------------------------+
void OnTick()
{
    CheckBalanceAndReset();  // Comprobar y restablecer el equilibrio en función de los umbrales
}

//+------------------------------------------------------------------+
//| Función de desinicialización experta|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    PrintBalanceResetResults();  // Salida de los resultados del reajuste de la balanza al registro
}

Funciones clave

1. Umbrales de pérdidas y ganancias ajustables

   • La biblioteca permite ajustar los umbrales de pérdidas y ganancias que activan los reinicios de saldo durante el proceso de backtesting. Estos umbrales pueden modificarse mediante parámetros de entrada, lo que facilita la personalización de las condiciones de prueba.

   Ejemplo:

input double profit_threshold = 8.0;  // Umbral de beneficio, por defecto es 8%.
input double loss_threshold = -6.0;   // Umbral de pérdida, por defecto es -6

2. Inicialización del saldo inicial

• Esta función almacena el saldo inicial de la cuenta al comienzo de la prueba. Sólo se ejecuta en el primer tick para capturar el saldo inicial de partida.

Ejemplo:

void InitBalance()
{
    initial_balance = AccountInfoDouble(ACCOUNT_BALANCE);  // Almacenamiento del saldo inicial
}

3. Lógica de restablecimiento de saldo

• El núcleo de la biblioteca compara el saldo actual con el inicial para calcular el porcentaje de beneficio o pérdida. Si el beneficio supera el umbral especificado (por ejemplo, 8%) o la pérdida supera su umbral (por ejemplo, -6%), el saldo se restablece al valor inicial.
• Puesta a cero del beneficio: La función TesterWithdrawal se utiliza para retirar el importe sobrante y devolver el saldo al valor inicial cuando se alcanza el umbral de beneficios.
• Reposición de pérdidas: La función TesterDeposit restablece el saldo al importe inicial cuando se alcanza el umbral de pérdidas.

Ejemplo:

void CheckBalanceAndReset()
{
    double current_balance = AccountInfoDouble(ACCOUNT_BALANCE);
    if (initial_balance == 0) {
        initial_balance = current_balance; // Primer tick, almacenar el 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

• Una vez finalizada la prueba, esta función muestra el número de restablecimientos realizados con éxito (tanto para pérdidas como para ganancias) y el número de días transcurridos entre cada restablecimiento. De este modo, se puede saber con qué frecuencia se restablecen los saldos durante la prueba.

Ejemplo:

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

Conclusión

Esta biblioteca ayuda a simular un entorno de negociación que se adhiere a los requisitos comunes de las empresas de negociación por cuenta propia. Al restablecer el saldo cuando se alcanzan los umbrales de beneficios y pérdidas predefinidos, permite a los operadores probar sus estrategias de forma más eficaz y analizar el rendimiento de sus EA en función de las normas de las empresas propietarias.

Descripción de los cambios y adiciones al código:

El nuevo código incluye varias mejoras y adiciones en comparación con el código antiguo. A continuación se ofrece una explicación detallada de lo que se ha añadido y modificado:

Nuevos parámetros de entrada:

• max_loss y min_won :

input double max_loss = 1;   // Pérdida máxima
input double min_won = 1;    // Min ganado

Propósito: Estos parámetros de entrada le permiten establecer la pérdida máxima permitida ( max_loss ) y el número mínimo de reinicios de ganancias exitosos requeridos ( min_won ). Proporcionan un mayor control sobre las condiciones de optimización.

Variables adicionales:

• reset_status[] :

string reset_status[]; // Matriz para almacenar el estado de cada reinicio

Propósito: Un array añadido para almacenar el estado ("Reinicio de beneficios" o "Reinicio de pérdidas") de cada evento de reinicio de saldo.

stopOptimización :

bool stopOptimization = false;

Propósito: Una bandera usada para indicar cuando la optimización debe ser detenida basada en ciertas condiciones.

badResult :

bool badResult = false; // Bandera para indicar un mal resultado de optimización

Propósito: Una bandera para marcar el resultado de la optimización como desfavorable, que se puede utilizar para influir en el resultado en OnTester() .

Modificaciones en CheckBalanceAndReset() :

• Grabación del estado de reinicio:

ArrayResize(reset_status, ArraySize(reset_status) + 1); // Redimensiona el array para registrar el estado de reinicio
reset_status[ArraySize(reset_status) - 1] = "Profit reset"; // Registrar el estado

Propósito: Cuando se produce un reinicio de beneficios, el estado se registra en el array reset_status[].

Manejo de reinicios de pérdidas con condición de parada de optimización:

if (TesterDeposit(deposit_amount))
{
    unsuccessful_resets++;  // Aumenta el contador de reinicios de pérdidas fallidas
    // Registrar la hora y el estado del reinicio
    ArrayResize(reset_status, ArraySize(reset_status) + 1);
    reset_status[ArraySize(reset_status) - 1] = "Loss reset";
    {
        stopOptimization = true;
        CheckStopCondition();  // Comprobar si se debe detener la optimización
    }
    PrintFormat("Loss reached. Balance has been reset to the initial value.");
}

Propósito: Después de un reinicio por pérdida, el código ahora incrementa unsuccessful_resets , registra el estado, establece stopOptimization a true , y llama a CheckStopCondition() para determinar si la optimización debe detenerse.

Nueva función CheckStopCondition() :

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

Propósito: Esta función comprueba si stopOptimization es verdadero y, si es así, marca el resultado como malo y detiene el pase de optimización actual usando TesterStop() .

Nueva Función OnTester() :

double OnTester()
{
    // Si el número de reinicios con éxito es inferior al mínimo requerido o se establece badResult
    if(successful_resets < min_won || badResult)
    {
        Print("Optimization failed: returning a highly unfavorable result.");
        // Devuelve un resultado muy desfavorable para estropear el pase de optimización
        return -999999;
    }

    // Calcular la diferencia entre reinicios con éxito y sin éxito
    int reset_difference = successful_resets - unsuccessful_resets;

    // Comprueba si la diferencia es negativa
    if(reset_difference < 0)
    {
        Print("Negative difference between successful and unsuccessful resets. Returning a highly unfavorable result.");
        // Devuelve un resultado muy desfavorable si la diferencia es negativa
        return -999999;
    }

    // Envía la diferencia al registro
    PrintFormat("Difference between successful and unsuccessful resets: %d", reset_difference);

    // Devuelve la diferencia como resultado del comprobador
    return reset_difference;
}

Propósito: Esta función proporciona un criterio personalizado para el proceso de optimización. Comprueba si el número de reinicios con éxito cumple el requisito mínimo o si el resultado es malo. Calcula la diferencia entre reinicios con éxito y sin éxito y devuelve este valor a menos que la diferencia sea negativa, en cuyo caso devuelve un resultado muy desfavorable para influir en el optimizador.

Mejoras en PrintBalanceResetResults() :

// Imprime las fechas de cada reinicio y el número de días entre ellos
for(int i = 1; i < ArraySize(reset_times); i++)
{
    // Calcular el número de días entre reinicios
    int days_between_resets = (reset_times[i] - reset_times[i-1]) / 86400; // 86400 segundos en un día
    // Imprime las fechas de reinicio, el estado y los días entre ellas
    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);
}

Propósito: La función ahora no sólo muestra el número de reinicios, sino que también detalla cada evento de reinicio, incluyendo la fecha, el estado y el número de días entre reinicios. Esto proporciona un registro más completo de las actividades de restablecimiento.

Inicialización y uso de variables:

• Comprobación inicial del saldo:

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

Finalidad: Garantiza que el saldo_inicial se establece correctamente en el primer tick.

Cálculo del porcentaje de beneficio:

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

Finalidad: Calcula el porcentaje de beneficio o pérdida respecto al saldo inicial.

Resumen de adiciones:

• Control del proceso de optimización:

  • El código incluye ahora mecanismos para detener el proceso de optimización en función de condiciones específicas, como superar el número máximo de reinicios fallidos o no alcanzar el número mínimo de reinicios correctos.

• Registro y seguimiento mejorados:

  • La adición de reset_status[] y el registro detallado en PrintBalanceResetResults() permite un mejor seguimiento de los eventos de restablecimiento y sus resultados.

• Integración con Optimizer mediante OnTester() :

  • Al implementar OnTester() , el script puede comunicar los resultados al motor de optimización, influyendo en la selección de conjuntos de parámetros basados en criterios personalizados.

Estos cambios mejoran la funcionalidad del script al proporcionar un mejor control sobre las operaciones comerciales durante la optimización, un registro más detallado de los eventos y la capacidad de influir en el proceso de optimización basándose en criterios definidos a medida.