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

MQL5 · Indicateurs

OnCalculate et prev_calculated en MQL5 : calculer vite et juste

OnCalculate() met à jour les buffers d’un indicateur à chaque tick. Les deux formes, le cycle de prev_calculated, begin, les calculs récursifs et une EMA chaînable complète.

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

OnCalculate() est la fonction que le terminal appelle pour qu’un indicateur personnalisé mette à jour ses buffers, en général à l’arrivée d’un nouveau tick. Son paramètre clé, prev_calculated, contient la valeur que la fonction a elle-même renvoyée à l’appel précédent. En renvoyant rates_total et en ne recalculant que les bougies à partir de prev_calculated - 1, un indicateur ne traite que ce qui a changé. Le principe tient en une phrase, mais ses détails (remise à zéro par le terminal, calculs récursifs, paramètre begin, valeur de retour 0) expliquent la plupart des indicateurs lents ou faux. Cette page les passe en revue.

Les deux formes de la fonction

Un indicateur déclare l’une ou l’autre forme, jamais les deux.

//--- forme 1 : calcul sur une seule série choisie par l'utilisateur
int OnCalculate(const int     rates_total,      // taille de price[]
                const int     prev_calculated,  // bougies traitées à l'appel précédent
                const int     begin,            // index des premières données significatives
                const double& price[]);         // série source

//--- forme 2 : accès à toutes les séries de la bougie
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[]);

La forme 1 reçoit un seul tableau, price[]. Son contenu est choisi par l’utilisateur dans l’onglet Paramètres de l’indicateur, via la liste « Appliquer à » : un prix (clôture, ouverture, médian…) ou les valeurs d’un autre indicateur déjà présent sur le graphique. Sans choix explicite, c’est la clôture. Cette forme rend votre indicateur chaînable : on peut l’appliquer à un RSI, à une moyenne, ou à n’importe quel autre indicateur, et un EA peut faire de même avec iCustom() en passant un handle comme dernier paramètre.

La forme 2 donne accès aux temps, aux quatre prix, aux volumes et au spread de chaque bougie. Elle est indispensable dès que le calcul combine plusieurs prix (amplitude, prix typique, true range) ou utilise le volume.

prev_calculated : le cycle complet

À chaque appel, le terminal fournit rates_total, le nombre de bougies disponibles, et prev_calculated, la valeur renvoyée au dernier appel. Quatre situations se présentent :

Situationprev_calculatedCe que l’indicateur doit faire
Premier appel0Tout calculer
Nouveau tick, même bougieégal à rates_totalRecalculer la dernière bougie
Nouvelle bougieégal à rates_total - 1Recalculer l’avant-dernière et calculer la nouvelle
Historique modifié (chargement plus profond, trou comblé)remis à 0 par le terminalTout recalculer

D’où le motif classique : start = (prev_calculated == 0) ? premier_index_valide : prev_calculated - 1. Le « – 1 » est indispensable : la dernière bougie traitée au tick précédent n’était pas close, ses prix ont pu changer depuis.

La quatrième ligne est la plus souvent oubliée. La documentation précise que lorsque les données de prix ont changé depuis le dernier appel, le terminal remet lui-même prev_calculated à zéro. Un indicateur qui mémorise des états dans des variables globales (un compteur, un dernier sommet, un cumul) doit donc réinitialiser ces variables quand prev_calculated vaut 0, faute de quoi il mélange l’ancien et le nouvel historique.

Que renvoyer ?

Dans la grande majorité des cas, renvoyez rates_total. Deux nuances :

  • Si les données nécessaires ne sont pas encore disponibles (pas assez de bougies, indicateur source pas encore calculé), renvoyez 0 pour forcer un calcul complet au prochain appel. La documentation signale que lorsque la fonction renvoie zéro, les valeurs de l’indicateur ne sont pas affichées dans la fenêtre de données : c’est un état transitoire, pas un état normal.
  • Si seule une partie des bougies a pu être calculée, vous pouvez renvoyer le nombre de bougies effectivement traitées : l’appel suivant reprendra à partir de là.

Renvoyer systématiquement 0 « pour être tranquille » est une erreur fréquente : l’indicateur recalcule tout l’historique à chaque tick, et ses valeurs n’apparaissent jamais dans la fenêtre de données.

Les calculs récursifs

Une moyenne exponentielle, un cumul ou un trailing dépendent de la valeur de la bougie précédente. Avec le motif prev_calculated - 1, c’est sans risque : la bougie start - 1 a été calculée lors d’un appel antérieur et n’est plus modifiée. Le piège apparaît lorsque l’on stocke la valeur précédente dans une variable plutôt que de la relire dans le buffer : à chaque tick de la même bougie, la variable a déjà été mise à jour par le tick précédent, et la récurrence s’applique plusieurs fois. Relisez toujours la valeur précédente dans le buffer, Buffer[i - 1], jamais dans une variable globale.

Le paramètre begin et PLOT_DRAW_BEGIN

Dans la forme 1, begin indique à partir de quel index price[] contient des données significatives. Si votre indicateur est appliqué à une moyenne de 50 périodes, les 49 premières valeurs de la source ne veulent rien dire, et begin vaut 49. Votre indicateur doit alors commencer son propre calcul à begin et décaler son début de tracé en conséquence avec PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, begin + période). L’exemple de la documentation procède ainsi : il règle PLOT_DRAW_BEGIN dans OnInit(), puis l’ajuste dans OnCalculate() lorsque begin est positif.

Exemple complet : une EMA chaînable avec gestion de begin

//+------------------------------------------------------------------+
//| EmaChainable.mq5 - forme 1 de OnCalculate, gestion de begin      |
//+------------------------------------------------------------------+
#property indicator_chart_window
#property indicator_buffers 1
#property indicator_plots   1
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrGoldenrod
#property indicator_width1  2
#property indicator_label1  "EMA"

input int InpPeriod = 21;   // période de l'EMA

double EmaBuffer[];
int    lastBegin = -1;      // begin connu au dernier appel

int OnInit()
  {
   SetIndexBuffer(0, EmaBuffer, INDICATOR_DATA);
   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, InpPeriod - 1);
   IndicatorSetString(INDICATOR_SHORTNAME, StringFormat("EMA(%d)", InpPeriod));
   return(INIT_SUCCEEDED);
  }

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[])
  {
   int first = begin + InpPeriod - 1;          // première bougie calculable
   if(rates_total <= first)
      return(0);                               // pas assez de données

   //--- la source a changé de début : on ajuste le tracé et on recalcule tout
   int from = prev_calculated - 1;
   if(begin != lastBegin)
     {
      PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, first);
      lastBegin = begin;
      from = -1;
     }

   ArraySetAsSeries(price, false);
   double alpha = 2.0 / (InpPeriod + 1.0);

   if(prev_calculated == 0 || from < first)
     {
      //--- initialisation : valeurs vides puis moyenne simple comme point de départ
      for(int i = 0; i < first; i++)
         EmaBuffer[i] = EMPTY_VALUE;
      double sum = 0.0;
      for(int i = begin; i <= first; i++)
         sum += price[i];
      EmaBuffer[first] = sum / InpPeriod;
      from = first + 1;
     }

   //--- récurrence : la valeur précédente est relue dans le buffer
   for(int i = from; i < rates_total; i++)
      EmaBuffer[i] = alpha * price[i] + (1.0 - alpha) * EmaBuffer[i - 1];

   return(rates_total);
  }

Faites l’essai : attachez une moyenne mobile de période 50 au graphique, puis faites glisser cet indicateur sur le graphique et choisissez, dans « Appliquer à », les données de l’indicateur précédent. Le tracé commence alors plus tard, à begin + période - 1, au lieu de produire une courbe absurde au début de l’historique.

Le cas from < first couvre aussi la situation où prev_calculated - 1 tomberait dans la zone de chauffe, par exemple après un historique très court. Les tableaux sont explicitement réglés en indexation classique : la documentation recommande de ne pas présumer du sens d’indexation et d’appeler ArraySetAsSeries() sur les tableaux utilisés.

Mesurer le coût de votre OnCalculate

Un indicateur appelé à chaque tick, sur plusieurs graphiques, peut ralentir tout le terminal, et surtout le testeur de stratégie lorsqu’un EA l’utilise. Pour vérifier que votre motif incrémental fonctionne, ajoutez temporairement un Print(rates_total - prev_calculated) : en régime normal, la valeur doit être 0 (même bougie) ou 1 (nouvelle bougie). Si vous voyez régulièrement de grandes valeurs, l’indicateur recalcule trop. Le profileur de MetaEditor, présenté sur la page Profiler et optimiser son code, permet ensuite de repérer les boucles coûteuses.

Pièges récapitulés

  • Boucle de 0 à rates_total à chaque tick : correct mais lent ; utilisez prev_calculated.
  • Oubli du « – 1 » : la dernière bougie reste figée sur la valeur de son premier tick.
  • États globaux non réinitialisés quand prev_calculated vaut 0.
  • Récurrence sur une variable au lieu du buffer : l’EMA dérive à chaque tick.
  • Retour systématique de 0 : recalcul permanent et fenêtre de données vide.
  • Sens d’indexation implicite : réglez-le explicitement, voir ArraySetAsSeries et indexation des séries.

Pour l’organisation des buffers que remplit OnCalculate(), voyez Buffers et styles de tracé. La rubrique Indicateurs en MQL5 rassemble les autres pages sur les indicateurs personnalisés.

FAQ

Que contient exactement prev_calculated ?

La valeur renvoyée par OnCalculate() lors de l’appel précédent. Elle vaut 0 au premier appel, et le terminal la remet à 0 lorsque l’historique des prix a changé.

Pourquoi recalculer à partir de prev_calculated – 1 et pas prev_calculated ?

Parce que la dernière bougie traitée au tick précédent n’était pas close : ses prix ont pu évoluer. La recalculer garantit que sa valeur finale est juste.

Quand utiliser la forme courte de OnCalculate ?

Quand le calcul porte sur une seule série. L’utilisateur choisit alors la source (prix ou autre indicateur) dans « Appliquer à », et un EA peut chaîner l’indicateur via iCustom().

Pourquoi mon indicateur n’affiche-t-il rien dans la fenêtre de données ?

Si OnCalculate() renvoie 0, la documentation indique que les valeurs ne sont pas affichées dans la fenêtre de données. Renvoyez rates_total une fois le calcul effectué.

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.