Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

MQL4 · Indicateurs

IndicatorCounted et prev_calculated en MQL4 : ne recalculer que l’utile

Un indicateur MQL4 efficace ne recalcule que les bougies nouvelles ou modifiées. Ancienne méthode avec start() et IndicatorCounted(), nouvelle méthode avec OnCalculate() et prev_calculated, et conversion de l’une à l’autre.

Mis à jour le 23 octobre 2026Lecture : 7 minPar Alix, OptiBot Trading

Un indicateur MQL4 est appelé à chaque tick. S’il recalcule à chaque fois toutes les bougies de l’historique, plusieurs dizaines de milliers parfois, il consomme inutilement le processeur, ralentit le terminal et rend les backtests des EA qui l’appellent très lents. La solution consiste à ne recalculer que les bougies qui ont changé : la bougie en cours et les éventuelles nouvelles bougies. MQL4 propose deux façons de connaître le nombre de bougies déjà calculées : la fonction IndicatorCounted(), utilisée avec l’ancienne fonction start(), et le paramètre prev_calculated de OnCalculate(), disponible dans les versions récentes du langage. Cette page explique les deux, la formule de la limite de boucle et la conversion d’un ancien indicateur.

L’ancienne méthode : start() et IndicatorCounted()

Dans les indicateurs écrits avant la refonte du langage, le calcul se trouve dans une fonction start(). À l’intérieur, IndicatorCounted() renvoie, selon la documentation, le nombre de bougies qui n’ont pas changé depuis le dernier lancement de l’indicateur. La fonction renvoie une valeur négative en cas d’erreur. La documentation précise aussi que la dernière bougie comptée doit être recalculée, d’où la décrémentation que l’on retrouve dans tous les anciens codes :

int start()
{
   int comptees = IndicatorCounted();
   if(comptees < 0) return(-1);          // erreur : on n'insiste pas
   if(comptees > 0) comptees--;          // la dernière bougie comptée est recalculée
   int limite = Bars - comptees;          // nombre de bougies à traiter

   for(int i = 0; i < limite; i++)
   {
      // calcul de la bougie i (indice 0 = bougie en cours)
   }
   return(0);
}

Bars est la variable prédéfinie qui contient le nombre de bougies du graphique. Au premier appel, IndicatorCounted() renvoie 0 et la boucle parcourt tout l’historique. Aux appels suivants, elle ne parcourt que la ou les dernières bougies.

Ce code fonctionne toujours, et vous le rencontrerez dans de nombreux indicateurs publiés. Mais il présente deux inconvénients : il dépend de variables globales comme Bars plutôt que de paramètres explicites, et il ne gère pas toujours correctement les bougies anciennes nécessaires au calcul. Une boucle qui lit Close[i + Periode] dépasse l’historique au premier appel si limite vaut Bars.

La nouvelle méthode : OnCalculate() et prev_calculated

Les indicateurs modernes utilisent OnCalculate(). La fonction reçoit en paramètres le nombre total de bougies, rates_total, et prev_calculated, qui contient la valeur que OnCalculate() a elle-même renvoyée lors de l’appel précédent. Le principe est donc entièrement sous votre contrôle : vous renvoyez rates_total à la fin du calcul, et au tick suivant, prev_calculated vous indique jusqu’où vous étiez allé.

int OnCalculate(const int rates_total, const int prev_calculated,
                const datetime &time[], const double &open[], const double &high[],
                const double &low[], const double &close[], const long &tick_volume[],
                const long &volume[], const int &spread[])
{
   int limite;
   if(prev_calculated == 0)
      limite = rates_total - Periode;               // premier appel : tout l'historique utilisable
   else
      limite = rates_total - prev_calculated + 1;   // bougie 0 + nouvelles bougies

   for(int i = limite - 1; i >= 0; i--)
   {
      // calcul de la bougie i
   }
   return(rates_total);
}

Analysons les trois situations possibles :

Situationprev_calculatedlimiteBougies recalculées
Premier appel0rates_total − Periodetout l’historique utilisable
Nouveau tick, même bougierates_total1la bougie 0
Nouvelle bougierates_total − 12la bougie 1, qui vient de se terminer, et la bougie 0

Le « + 1 » garantit que la bougie précédemment en cours est finalisée avec ses prix définitifs. C’est une erreur fréquente de l’oublier : la bougie qui vient de se clôturer garde alors la valeur calculée lors de son dernier tick, souvent proche mais pas identique à sa valeur finale.

Quand prev_calculated revient à zéro

Le terminal remet prev_calculated à 0 dans plusieurs situations : premier lancement, changement de paramètres, changement d’unité de temps, mais aussi lorsque l’historique est modifié, par exemple quand des bougies manquantes sont téléchargées ou que la connexion est rétablie après une coupure. Votre code doit donc traiter prev_calculated == 0 comme un recalcul complet, et non comme un cas exceptionnel. Si votre indicateur maintient des variables globales en plus des buffers (un compteur, une valeur cumulée), réinitialisez-les dans ce cas, sinon elles conserveront des valeurs issues de l’ancien historique.

Pour la même raison, évitez de considérer que la différence entre rates_total et prev_calculated vaut toujours 0 ou 1. Après une reconnexion, elle peut valoir plusieurs dizaines si des bougies ont été ajoutées en une fois. La formule de la limite ci-dessus gère ce cas sans traitement particulier.

Exemple complet : moyenne de l’amplitude des bougies

Cet indicateur affiche, dans une sous-fenêtre, la moyenne de l’amplitude haut − bas des N dernières bougies. Il applique la méthode prev_calculated et protège l’accès aux bougies anciennes.

#property strict
#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1  clrSteelBlue
#property indicator_width1  2

input int Periode = 20;

double BufAmplitude[];

int OnInit()
{
   if(Periode < 1) return(INIT_PARAMETERS_INCORRECT);
   SetIndexBuffer(0, BufAmplitude);
   SetIndexStyle(0, DRAW_LINE);
   SetIndexLabel(0, "Amplitude moyenne");
   SetIndexDrawBegin(0, Periode);
   IndicatorShortName("AmplitudeMoy(" + IntegerToString(Periode) + ")");
   return(INIT_SUCCEEDED);
}

int OnCalculate(const int rates_total, const int prev_calculated,
                const datetime &time[], const double &open[], const double &high[],
                const double &low[], const double &close[], const long &tick_volume[],
                const long &volume[], const int &spread[])
{
   if(rates_total <= Periode) return(0);           // historique insuffisant : on réessaiera

   int limite = (prev_calculated == 0) ? rates_total - Periode
                                       : rates_total - prev_calculated + 1;

   for(int i = limite - 1; i >= 0; i--)
   {
      double somme = 0;
      for(int j = 0; j < Periode; j++)             // bougies i à i + Periode - 1
         somme += High[i + j] - Low[i + j];
      BufAmplitude[i] = somme / Periode;
   }
   return(rates_total);
}

Au premier appel, la boucle commence à rates_total - Periode - 1 : la bougie la plus ancienne lue est alors rates_total - 2, toujours dans l’historique. Renvoyer 0 quand l’historique est trop court force le terminal à repasser prev_calculated = 0 au prochain appel, donc à retenter le calcul complet.

Mesurer le gain obtenu

L’effet du recalcul incrémental est facile à constater. Sur un graphique M1 comptant cent mille bougies, un indicateur de période 20 qui recalcule tout à chaque tick effectue environ deux millions d’additions par tick ; la version incrémentale en effectue quarante. Sur un graphique isolé, la différence passe presque inaperçue. Elle devient en revanche considérable lorsqu’un Expert Advisor appelle l’indicateur via iCustom() dans le testeur de stratégie, où des millions de ticks sont simulés, et plus encore en optimisation, où le test est répété des centaines de fois.

Convertir un ancien indicateur

Pour passer d’un code start() / IndicatorCounted() à OnCalculate() :

  1. renommez init() en OnInit() et faites-la renvoyer INIT_SUCCEEDED ;
  2. remplacez start() par la signature complète de OnCalculate() ;
  3. remplacez IndicatorCounted() par prev_calculated et Bars par rates_total dans le calcul de la limite ;
  4. ajoutez le « + 1 » pour recalculer la bougie précédente, et vérifiez la borne du premier calcul ;
  5. terminez la fonction par return(rates_total); ;
  6. compilez avec #property strict et corrigez les avertissements.

Comparez ensuite l’ancien et le nouvel indicateur sur le même graphique : les courbes doivent se superposer exactement. Les autres changements à prévoir lors d’une migration vers MetaTrader 5 sont résumés dans Différences entre MQL4 et MQL5, et l’équivalent MQL5 de ce mécanisme dans OnCalculate et prev_calculated en MQL5.

Pièges fréquents

  • Renvoyer une autre valeur que rates_total : si OnCalculate() renvoie 0 à chaque appel, prev_calculated reste à 0 et l’indicateur recalcule tout à chaque tick, exactement ce que l’on cherche à éviter.
  • Boucle croissante sur un calcul récursif : pour une moyenne exponentielle ou tout calcul qui dépend de la valeur précédente, parcourez les bougies de la plus ancienne à la plus récente, c’est-à-dire de limite - 1 vers 0.
  • Lire des bougies futures : un calcul qui utilise High[i - 1] regarde une bougie plus récente que i. Il donnera de bons résultats en historique et faux en temps réel.
  • Calculs lourds dans un EA : un indicateur mal optimisé appelé via iCustom() ralentit fortement le testeur. C’est le premier point à vérifier si un backtest est anormalement lent.

Retrouvez la construction complète d’un indicateur dans Créer un indicateur en MQL4 et l’ensemble des pages de la rubrique Indicateurs en MQL4.

FAQ

IndicatorCounted() fonctionne-t-il encore ?

Oui, il reste disponible et utilisé dans de nombreux indicateurs existants écrits avec start(). Pour un nouvel indicateur, prev_calculated, fourni par OnCalculate(), est plus explicite et plus simple à maîtriser.

Pourquoi recalculer la dernière bougie déjà calculée ?

Parce que ses prix ont pu changer depuis le dernier calcul : tant qu’une bougie n’est pas clôturée, son plus haut, son plus bas et sa clôture évoluent. Le recalcul garantit que la valeur finale correspond aux prix définitifs.

Que contient prev_calculated exactement ?

La valeur que votre fonction OnCalculate() a renvoyée lors de l’appel précédent, ou 0 lors du premier appel et après certaines réinitialisations (changement de paramètres, modification de l’historique).

Mon indicateur affiche des valeurs fausses après une reconnexion, pourquoi ?

Après une reconnexion, plusieurs bougies peuvent être ajoutées d’un coup, ou l’historique entièrement rechargé avec prev_calculated à 0. Si votre code suppose qu’une seule bougie est ajoutée à la fois, ou conserve des variables globales non réinitialisées, il produit des valeurs incohérentes.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.