probleme d'ouverture d'ordre selon de nombreux paramatres lors de backtest

benoith 2023.08.04 20:40

bonjour à tous je cherche de l'aide car j'ai un problème d'ouverture d'ordre en phase de backtest sur de nombreux indicateurs implanté

dans mon code. Pouvez vous m'aider à trouver la source du problème sur cet ea complètement fonctionnel sur le graphique.

j'ai également trois soucis sur : possible loss of data due to type conversion ligne 95/111/217

que je n'arrive pas à optimiser

merci à tous

//+------------------------------------------------------------------+
//|                          Scalping EA                   |
//|                    Copyright 2023, benoit                      |
//|                          https://www.benoit                    |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, benoit"
#property link      "https://benoit"
#property version   "1.01"
#property strict

// Paramètres d'entrée
double STOP_LOSS_DA_MULTIPLIER = 1.0;
double RISK_PERCENTAGE = 2.0;
double TAKE_PROFIT_ATR_MULTIPLIER = 2.0;
bool USE_TRAILING_STOP = true;
double TRAILING_STOP_DA_MULTIPLIER = 1.5;
double TRAILING_STOP_ATR_MULTIPLIER = 1.0;
int VWAP_PERIODS = 5;
double ATR_THRESHOLD = 0.0025;

// Période pour la moyenne mobile de plus long terme (filtre)
#define LONG_TERM_MA_PERIOD 50

// Variables globales pour le stockage des indicateurs et valeurs calculées
double dar[];
double tickValueGlobal;
double stopLossPipsGlobal;
double lotSize;
double atrValue;
double vwapValue[];
double totalVolume[];


//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    // Initialiser les tableaux
    ArrayInitialize(dar, 0);
    ArrayInitialize(vwapValue, 0);
    ArrayInitialize(totalVolume, 0);

    // Calculer la taille du lot en fonction du risque
    CalculateLotSize();

    // Pré-calculer la DAR (Daily Average Range)
    CalculateDailyAverageRange();

    // Pré-calculer la valeur du tick
    tickValueGlobal = MarketInfo(Symbol(), MODE_TICKVALUE);

    // Optimiser les paramètres
    OptimizeParameters();

    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    // Pas besoin de code ici pour le moment
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    // Vérifier l'heure actuelle
    datetime now = TimeLocal();
    int hour = TimeHour(now);
    int minute = TimeMinute(now);

    // Mettre à jour le VWAP à chaque nouveau tick
    CalculateVWAP();

    // Conditions d'ouverture des trades seulement pendant le chevauchement des sessions de Londres et de New York (8h00 à 17h00 GMT)
    if (hour >= 8 && hour < 17)
    {
        // Filtrer les signaux avec la moyenne mobile de plus long terme
        if (IsTrendUp() && IsBuySignal())
        {
            double stopLoss = STOP_LOSS_DA_MULTIPLIER * dar[0];
            double takeProfit = TAKE_PROFIT_ATR_MULTIPLIER * dar[0];

            double trailingStop = 0;
            if (USE_TRAILING_STOP)
            {
                trailingStop = CalculateTrailingStop(TRAILING_STOP_DA_MULTIPLIER, TRAILING_STOP_ATR_MULTIPLIER);
            }

            int result = OrderSend(Symbol(), OP_BUY, lotSize, Ask, 3, NormalizeDouble(Ask - stopLoss * Point, Digits), NormalizeDouble(Ask + takeProfit * Point, Digits), "Buy Order", 0, trailingStop, Green);
            CheckForErrors(result);
        }

        // Filtrer les signaux avec la moyenne mobile de plus long terme
        if (IsTrendDown() && IsSellSignal())
        {
            double stopLoss = STOP_LOSS_DA_MULTIPLIER * dar[0];
            double takeProfit = TAKE_PROFIT_ATR_MULTIPLIER * dar[0];

            double trailingStop = 0;
            if (USE_TRAILING_STOP)
            {
                trailingStop = CalculateTrailingStop(TRAILING_STOP_DA_MULTIPLIER, TRAILING_STOP_ATR_MULTIPLIER);
            }

            int result = OrderSend(Symbol(), OP_SELL, lotSize, Bid, 3, NormalizeDouble(Bid + stopLoss * Point, Digits), NormalizeDouble(Bid - takeProfit * Point, Digits), "Sell Order", 0, trailingStop, Red);
            CheckForErrors(result);
        }
    }
}

// Vérifier les conditions d'achat
bool IsBuySignal()
{
    bool emaCross = iMA(NULL, 0, 5, 0, MODE_EMA, PRICE_CLOSE, 0) > iMA(NULL, 0, 10, 0, MODE_EMA, PRICE_CLOSE, 0);
    bool nearLowerBB = iClose(Symbol(), 0, 1) < iBands(NULL, 0, 20, 2, 0, PRICE_CLOSE, MODE_LOWER, 1);
    bool rsiCheck = iRSI(NULL, 0, 14, PRICE_CLOSE, 0) < 70;
    bool macdCross = iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_MAIN, 0) > iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_SIGNAL, 0);
    bool stochCheck = iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 0) < 80 && iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_SIGNAL, 0) < 80;

    // Ajouter le filtre VWAP
    bool vwapBuySignal = Close[1] < vwapValue[0] && Close[0] > vwapValue[0];

    // Ajouter les conditions pour augmenter le nombre de trades
    double currentATR = iATR(NULL, 0, 14, 0);
    double thresholdATR = ATR_THRESHOLD;

    return emaCross && nearLowerBB && rsiCheck && macdCross && stochCheck && currentATR < thresholdATR && vwapBuySignal;
}

// Vérifier les conditions de vente
bool IsSellSignal()
{
    bool emaCross = iMA(NULL, 0, 5, 0, MODE_EMA, PRICE_CLOSE, 0) < iMA(NULL, 0, 10, 0, MODE_EMA, PRICE_CLOSE, 0);
    bool nearUpperBB = iClose(Symbol(), 0, 1) > iBands(NULL, 0, 20, 2, 0, PRICE_CLOSE, MODE_UPPER, 1);
    bool rsiCheck = iRSI(NULL, 0, 14, PRICE_CLOSE, 0) > 30;
    bool macdCross = iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_MAIN, 0) < iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_SIGNAL, 0);
    bool stochCheck = iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 0) > 20 && iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_SIGNAL, 0) > 20;

    // Ajouter le filtre VWAP
    bool vwapSellSignal = Close[1] > vwapValue[0] && Close[0] < vwapValue[0];

    return emaCross && nearUpperBB && rsiCheck && macdCross && stochCheck && vwapSellSignal;
}

//+------------------------------------------------------------------+
//| Vérifier la tendance générale (filtre)                           |
//+------------------------------------------------------------------+
bool IsTrendUp()
{
    double longTermMA = iMA(NULL, 0, LONG_TERM_MA_PERIOD, 0, MODE_SMA, PRICE_CLOSE, 0);
    double currentPrice = Close[0];

    return currentPrice > longTermMA;
}

bool IsTrendDown()
{
    double longTermMA = iMA(NULL, 0, LONG_TERM_MA_PERIOD, 0, MODE_SMA, PRICE_CLOSE, 0);
    double currentPrice = Close[0];

    return currentPrice < longTermMA;
}

// Calculer la taille du lot en fonction du risque
double CalculateLotSize()
{
    double accountBalance = AccountBalance();
    double riskAmount = accountBalance * RISK_PERCENTAGE / 100;
    double tickValueLocal = MarketInfo(Symbol(), MODE_TICKVALUE);
    double stopLossPipsLocal = STOP_LOSS_DA_MULTIPLIER * CalculateDailyAverageRange();

    lotSize = NormalizeDouble(riskAmount / (stopLossPipsLocal * tickValueLocal), 2);
    return lotSize;
}

// Calculer la DAR (Daily Average Range)
double CalculateDailyAverageRange()
{
    double dailyHigh = iHigh(Symbol(), 0, 1);
    double dailyLow = iLow(Symbol(), 0, 1);
    dar[0] = dailyHigh - dailyLow;

    return dar[0];
}

//+------------------------------------------------------------------+
//| Calculer le trailing stop en fonction de l'ATR                   |
//+------------------------------------------------------------------+
double CalculateTrailingStop(double darMultiplier, double atrMultiplier)
{
    double atr = iATR(NULL, 0, 14, 0); // Calculer l'ATR sur 14 périodes
    atrValue = atr * atrMultiplier;

    // Trailing stop basé sur l'ATR
    double trailingStop = darMultiplier * dar[0] - atrValue * Point;

    return NormalizeDouble(trailingStop, Digits);
}

//+------------------------------------------------------------------+
//| Calculer le VWAP                                                 |
//+------------------------------------------------------------------+
void CalculateVWAP()
{
    totalVolume[0] = 0;
    double sumPriceVolume = 0;

    for (int i = 0; i < VWAP_PERIODS; i++)
    {
        double price = iClose(NULL, 0, i);
        double volume = iVolume(NULL, 0, i);

        sumPriceVolume += price * volume;
        totalVolume[0] += volume;
    }

    if (totalVolume[0] > 0)
    {
        vwapValue[0] = sumPriceVolume / totalVolume[0];
    }
}

//+------------------------------------------------------------------+
//| Gestion des erreurs                                              |
//+------------------------------------------------------------------+
void CheckForErrors(int result)
{
    if (result < 0)
    {
        string errorDescription = ErrorDescription(result);
        Print("Erreur lors de l'envoi de l'ordre : ", errorDescription);
    }
}

string ErrorDescription(int error_code)
{
    switch (error_code)
    {
        case 0: return "Aucune erreur";
        case 1: return "Erreur non spécifiée";
        case 2: return "Fichier non trouvé";
        case 3: return "Erreur d'accès au fichier";
        case 4: return "Erreur d'écriture dans le fichier";
        // Ajoutez d'autres cas pour les codes d'erreur supplémentaires si nécessaire
        default: return "Code d'erreur inconnu";
    }
}

//+------------------------------------------------------------------+
//| Fonction pour optimiser les paramètres                          |
//+------------------------------------------------------------------+
void OptimizeParameters()
{
    double bestProfit = -999999; // Initialisation avec une valeur négative élevée
    double bestStopLoss = 0;
    double bestRiskPercentage = 0;
    double bestTakeProfit = 0;
    double bestTrailingStopDA = 0;
    double bestTrailingStopATR = 0;

    for (int i = 1; i <= 10; i++) // Boucle pour StopLossDARMultiplier (valeurs de 1 à 10)
    {
        for (int j = 1; j <= 5; j++) // Boucle pour RiskPercentage (valeurs de 1 à 5)
        {
            for (int k = 1; k <= 5; k++) // Boucle pour TakeProfitATRMultiplier (valeurs de 1 à 5)
            {
                for (int l = 1; l <= 10; l++) // Boucle pour TrailingStopDARMultiplier (valeurs de 1 à 10)
                {
                    for (int m = 1; m <= 5; m++) // Boucle pour TrailingStopATRMultiplier (valeurs de 1 à 5)
                    {
                        // Définir les paramètres pour l'optimisation
                        STOP_LOSS_DA_MULTIPLIER = i;
                        RISK_PERCENTAGE = j;
                        TAKE_PROFIT_ATR_MULTIPLIER = k;
                        TRAILING_STOP_DA_MULTIPLIER = l;
                        TRAILING_STOP_ATR_MULTIPLIER = m;

                        // Exécuter le test de stratégie avec les paramètres actuels
                        double currentProfit = BacktestStrategy();

                        // Vérifier si les résultats actuels sont meilleurs que les meilleurs résultats précédents
                        if (currentProfit > bestProfit)
                        {
                            bestProfit = currentProfit;
                            bestStopLoss = i;
                            bestRiskPercentage = j;
                            bestTakeProfit = k;
                            bestTrailingStopDA = l;
                            bestTrailingStopATR = m;
                        }
                    }
                }
            }
        }
    }

    // Afficher les meilleurs paramètres
    Print("Meilleurs paramètres trouvés :");
    Print("StopLossDARMultiplier =", bestStopLoss);
    Print("RiskPercentage =", bestRiskPercentage);
    Print("TakeProfitATRMultiplier =", bestTakeProfit);
    Print("TrailingStopDARMultiplier =", bestTrailingStopDA);
    Print("TrailingStopATRMultiplier =", bestTrailingStopATR);
}

//+------------------------------------------------------------------+
//| Test de la stratégie avec les paramètres actuels                |
//+------------------------------------------------------------------+
double BacktestStrategy()
{
    double initialBalance = AccountBalance();
    double currentBalance = initialBalance;

    // Boucle de backtest sur les données historiques
    for (int i = Bars - 1; i >= 0; i--)
    {
        OnTick(); // Exécuter la logique de trading à chaque tick
        currentBalance = AccountBalance();
    }

    // Calculer le profit total
    double profit = currentBalance - initialBalance;

    return profit;
}

Gerard Willia G J B M Dinh Sy 2023.08.05 07:37 #1

benoith:

bonjour à tous je cherche de l'aide car j'ai un problème d'ouverture d'ordre en phase de backtest sur de nombreux indicateurs implanté

dans mon code. Pouvez vous m'aider à trouver la source du problème sur cet ea complètement fonctionnel sur le graphique.

j'ai également trois soucis sur : possible loss of data due to type conversion ligne 95/111/217

que je n'arrive pas à optimiser

merci à tous

Bonjour
Pour ton erreur 'possible loss" c'est assez simple
C'est une erreur de type de données
Par exemple

double prix = 1.23456;
int intPrice = prix;

Essayer de mettre un double dans un int, tu risques clairement une perte de données

Que les gains soient avec toi

Aide au codage Fractal Break Out-Stuck Questions des débutants MQL5

benoith 2023.08.05 08:05 #2

William210 #:

Bonjour
Pour ton erreur 'possible loss" c'est assez simple
C'est une erreur de type de données
Par exemple

Essayer de mettre un double dans un int, tu risques clairement une perte de données

Que les gains soient avec toi

Merci beaucoup cela fonctionne pour les erreurs possible le loss maintenant.

Par contre, y a t'il qq pour m'expliquer pourquoi mon ea n'exécute aucun ordre en backtest ? Merci

Gerard Willia G J B M Dinh Sy 2023.08.06 15:09 #3

Bonjour
je t'ai fais un MP
Pour moi tes appels d'indicateurs ne sont pas bons..

bool emaCross = iMA(NULL, 0, 5, 0, MODE_EMA, PRICE_CLOSE, 0) < iMA(NULL, 0, 10, 0, MODE_EMA, PRICE_CLOSE, 0);

ima et tous les autres, retourne un handle, pas un double, pas un bool

ALAIN MICHEL AUGE 2023.08.07 14:58 #4

Bonjour, vous avez plusieurs problème dans votre code pour commencer essayez ceci pour comparer vos données

bool IsBuySignal()
{
    bool res=false;
    bool emaCross = false;
    if(iMA(NULL, 0, 5, 0, MODE_EMA, PRICE_CLOSE, 0) > iMA(NULL, 0, 10, 0, MODE_EMA, PRICE_CLOSE, 0)){emaCross=true;}
    bool nearLowerBB = false;
    if(iClose(Symbol(), 0, 1) < iBands(NULL, 0, 20, 2, 0, PRICE_CLOSE, MODE_LOWER, 1)){nearLowerBB=true;}
    bool rsiCheck = false;
    if(iRSI(NULL, 0, 14, PRICE_CLOSE, 0) < 70){rsiCheck=true;}
    bool macdCross = false;
    if(iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_MAIN, 0) > iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_SIGNAL, 0)){macdCross=true;}
    bool stochCheck = false;
    if(iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 0) < 80 && iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_SIGNAL, 0) < 80){stochCheck=true;}

    // Ajouter le filtre VWAP
    bool vwapBuySignal = false;
    if(Close[1] < vwapValue[0] && Close[0] > vwapValue[0]){vwapBuySignal=true;}

    // Ajouter les conditions pour augmenter le nombre de trades
    double currentATR = iATR(NULL, 0, 14, 0);
    double thresholdATR = ATR_THRESHOLD;
    
    if(emaCross==true && nearLowerBB==true && rsiCheck==true && macdCross==true && stochCheck==true && vwapBuySignal==true){res=true;}

    return (res);
}

// Vérifier les conditions de vente
bool IsSellSignal()
{
    bool res=false;
    bool emaCross = false;
    if(iMA(NULL, 0, 5, 0, MODE_EMA, PRICE_CLOSE, 0) < iMA(NULL, 0, 10, 0, MODE_EMA, PRICE_CLOSE, 0)){emaCross=true;}
    bool nearUpperBB = false;
    if(iClose(Symbol(), 0, 1) > iBands(NULL, 0, 20, 2, 0, PRICE_CLOSE, MODE_UPPER, 1)){nearUpperBB=true;}
    bool rsiCheck = false;
    if(iRSI(NULL, 0, 14, PRICE_CLOSE, 0) > 30){rsiCheck=true;}
    bool macdCross = false;
    if(iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_MAIN, 0) < iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_SIGNAL, 0)){macdCross=true;}
    bool stochCheck = false;
    if(iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 0) > 20 && iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_SIGNAL, 0) > 20){stochCheck=true;}

    // Ajouter le filtre VWAP
    bool vwapSellSignal = false;
    if(Close[1] > vwapValue[0] && Close[0] < vwapValue[0]){vwapSellSignal=true;}

    if(emaCross==true && nearUpperBB==true && rsiCheck==true && macdCross==true && stochCheck==true && vwapSellSignal==true){res=true;}

    return (res);
}

Ensuite vous avez des souci pour le calcul du lot vous essayez de diviser par 0 et vos tableaux n'ont pas de taille vous aurez une erreur, il doit y avoir encore des erreurs

Comment obtenir des informations Caractéristiques du langage mql5, Erreurs, bugs, questions

benoith 2023.08.07 17:43 #5

ALAIN MICHEL AUGE #:

Bonjour, vous avez plusieurs problème dans votre code pour commencer essayez ceci pour comparer vos données

Ensuite vous avez des souci pour le calcul du lot vous essayez de diviser par 0 et vos tableaux n'ont pas de taille vous aurez une erreur, il doit y avoir encore des erreurs

Merci pour votre aide cela a grandement amélioré mon code, et ma permis de modifier certaines données d'entrée. Merci encore

Nouveau commentaire