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.
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 :
| Situation | prev_calculated | Ce que l’indicateur doit faire |
|---|---|---|
| Premier appel | 0 | Tout calculer |
| Nouveau tick, même bougie | égal à rates_total | Recalculer la dernière bougie |
| Nouvelle bougie | égal à rates_total - 1 | Recalculer l’avant-dernière et calculer la nouvelle |
| Historique modifié (chargement plus profond, trou comblé) | remis à 0 par le terminal | Tout 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 ; utilisezprev_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_calculatedvaut 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é.
- Handles d’indicateurs et CopyBuffer
- iMA : moyennes mobiles
- iRSI : Relative Strength Index
- iMACD
- iBands : bandes de Bollinger
- iATR : Average True Range
- iStochastic
- iADX
- iCCI
- iMomentum
- iIchimoku
- iSAR : Parabolic SAR
- iEnvelopes
- iWPR : Williams %R
- iAO : Awesome Oscillator
- iAC : Accelerator Oscillator
- iAlligator
- iFractals
- iOBV : On Balance Volume
- iMFI : Money Flow Index
- iVolumes
- iStdDev : écart-type
- iDeMarker
- iBearsPower et iBullsPower
- iForce
- iOsMA
- iRVI
- iAMA : moyenne mobile adaptative
- iDEMA et iTEMA
- iFrAMA
- iCustom : appeler un indicateur personnalisé
- Créer un indicateur personnalisé
- Buffers et styles de tracé
- Indicateur multi-timeframe
- Objets graphiques (ObjectCreate)
