MQL5 · Bases du langage
ArraySetAsSeries en MQL5 : comprendre l’indexation des séries
Pourquoi tab[0] désigne tantôt la barre la plus ancienne, tantôt la barre en cours : fonctionnement d’ArraySetAsSeries, comportement des fonctions Copy et règles pour éviter les signaux inversés.
ArraySetAsSeries(tableau, true) inverse le sens d’adressage d’un tableau dynamique : l’index 0 désigne alors l’élément le plus récent (la barre en cours), l’index 1 la barre précédente, et ainsi de suite, comme dans les séries temporelles de MetaTrader. Sans cet appel, un tableau rempli par CopyClose() ou CopyRates() est indexé de gauche à droite : l’index 0 correspond à la barre la plus ancienne copiée. C’est la cause d’innombrables signaux inversés chez les développeurs qui arrivent de MQL4, où Close[0] désignait toujours la dernière barre.
Cette page fait partie de la rubrique Les bases du langage MQL5. Les tableaux en général sont présentés dans Tableaux statiques et dynamiques.
Deux sens d’indexation
La documentation officielle distingue deux conventions :
- les tableaux ordinaires et les buffers d’indicateurs sont indexés par défaut de gauche à droite : le premier élément, d’index 0, est à l’extrême gauche ;
- les séries temporelles ont une indexation inversée : leur premier élément est à l’extrême droite, c’est-à-dire la donnée la plus récente. Sur un graphique journalier, l’index 0 est le jour en cours, non terminé, et l’index 1 la veille.
Le point clé est que ArraySetAsSeries() ne déplace aucune donnée en mémoire. La documentation précise que la fonction modifie uniquement la manière d’adresser les éléments, pas leur stockage physique. C’est donc une opération instantanée, quelle que soit la taille du tableau.
Signature et restrictions
La signature documentée est :
bool ArraySetAsSeries(
const void& array[], // tableau par reference
bool flag // true = indexation inversee (serie)
);
Elle renvoie true en cas de succès, false sinon. Deux restrictions sont explicites dans la documentation : le drapeau de série ne peut pas être appliqué à un tableau multidimensionnel, ni à un tableau statique. La fonction s’utilise donc sur des tableaux dynamiques à une dimension, ce qui correspond exactement aux tableaux de prix et de valeurs d’indicateurs.
Deux fonctions complémentaires existent : ArrayGetAsSeries() indique le sens d’indexation actuel d’un tableau, et ArrayIsSeries() indique si le tableau est une véritable série temporelle (comme les tableaux transmis à OnCalculate()). La documentation recommande de ne pas se fier aux valeurs par défaut et d’appeler explicitement ArraySetAsSeries() sur les tableaux avec lesquels on travaille.
Ce que font les fonctions de copie
Les fonctions CopyRates(), CopyClose(), CopyTime() et CopyBuffer() considèrent toujours la source comme une série : le paramètre de position 0 désigne la barre en cours, et CopyClose(_Symbol, _Period, 0, 3, tab) copie donc les trois dernières barres. La documentation précise que, quel que soit le réglage du tableau de destination, l’élément le plus ancien est stocké au début de la mémoire physique.
Autrement dit, après cet appel :
| Réglage du tableau | tab[0] | tab[2] |
|---|---|---|
| Par défaut (non série) | la plus ancienne des trois barres copiées | la barre en cours |
ArraySetAsSeries(tab, true) | la barre en cours | la plus ancienne des trois |
Le paramètre de départ de la copie et le sens d’indexation du tableau sont deux notions indépendantes : le premier choisit quelles barres sont copiées, le second comment on les lit ensuite.
Le cas des indicateurs
Dans un indicateur, les tableaux reçus par OnCalculate() (time[], open[], close[]…) et les buffers déclarés avec SetIndexBuffer() sont, par défaut, indexés de gauche à droite. C’est cohérent avec le calcul incrémental à partir de prev_calculated : on boucle de la plus ancienne barre non calculée vers la plus récente, avec un index croissant. Si vous préférez raisonner en mode série, appliquez ArraySetAsSeries() à tous les tableaux utilisés, buffers compris, et adaptez la boucle. Mélanger les deux conventions dans un même calcul est l’erreur la plus fréquente. Le mécanisme de prev_calculated est détaillé dans OnCalculate et prev_calculated.
Effet sur les autres fonctions de tableau
Le drapeau de série n’est pas pris en compte de la même manière par toutes les fonctions :
ArrayMaximum()etArrayMinimum()en tiennent compte : l’index renvoyé correspond au sens d’adressage du tableau ;ArraySort()trie toujours par ordre croissant, quel que soit le drapeau, selon la documentation ;ArrayCopy()ajuste correctement la position de départ pour les tableaux en série, et un tableau de destination dynamique en série s’agrandit si nécessaire.
Exemple complet : vérifier le sens d’indexation
Ce script copie les mêmes barres dans deux tableaux, l’un laissé par défaut, l’autre passé en série, et affiche ce que contient l’index 0 de chacun.
//+------------------------------------------------------------------+
//| Script : effet de ArraySetAsSeries sur un tableau de prix |
//+------------------------------------------------------------------+
void OnStart()
{
double closeDefaut[], closeSerie[];
datetime heures[];
// Le tableau des heures et closeSerie sont passes en serie : index 0 = barre courante
ArraySetAsSeries(closeSerie, true);
ArraySetAsSeries(heures, true);
int n1 = CopyClose(_Symbol, _Period, 0, 5, closeDefaut); // 5 dernieres barres
int n2 = CopyClose(_Symbol, _Period, 0, 5, closeSerie);
int n3 = CopyTime(_Symbol, _Period, 0, 5, heures);
if(n1 != 5 || n2 != 5 || n3 != 5)
{
Print("Copie incomplete, erreur ", GetLastError());
return;
}
PrintFormat("Serie ? defaut=%s, serie=%s",
ArrayGetAsSeries(closeDefaut) ? "oui" : "non",
ArrayGetAsSeries(closeSerie) ? "oui" : "non");
for(int i = 0; i < 5; i++)
{
// closeDefaut[i] et closeSerie[4 - i] designent la meme barre
PrintFormat("i=%d | defaut %.*f | serie %.*f (barre de %s)",
i, _Digits, closeDefaut[i], _Digits, closeSerie[i],
TimeToString(heures[i]));
}
// Exemple de signal : cloture de la derniere barre terminee au-dessus de la precedente
bool hausse = (closeSerie[1] > closeSerie[2]); // lisible grace a l'indexation serie
PrintFormat("Derniere barre terminee haussiere : %s", hausse ? "oui" : "non");
}
En exécutant ce script sur n’importe quel graphique, vous verrez que closeDefaut[0] est égal à closeSerie[4] : il s’agit de la même barre, la plus ancienne des cinq. Le tableau heures, également en série, permet de vérifier à quelle barre correspond chaque index de closeSerie.
Diagnostiquer un problème d’indexation
Un EA qui achète systématiquement au mauvais moment, ou dont le signal semble décalé de plusieurs dizaines de barres, souffre souvent d’une indexation inversée. Pour le vérifier, copiez en même temps les heures d’ouverture avec CopyTime() dans un tableau réglé de la même façon que vos prix, puis affichez dans le journal l’heure associée aux index 0, 1 et au dernier index. Si l’index 0 affiche une date ancienne, le tableau n’est pas en série. Ce contrôle prend deux lignes de code et lève le doute immédiatement. En backtest, le mode visuel permet ensuite de comparer la barre signalée dans le journal avec celle du graphique.
Un autre symptôme typique est un croisement de moyennes détecté avec un retard égal au nombre de barres copiées : l’EA compare en réalité les deux valeurs les plus anciennes du tableau au lieu des deux plus récentes.
Bonnes pratiques dans un Expert Advisor
- Décidez d’une convention unique pour tout l’EA. La plupart des développeurs choisissent le mode série, qui correspond à la lecture naturelle d’un graphique : 0 pour la barre en cours, 1 pour la dernière barre close.
- Appelez
ArraySetAsSeries()une fois, juste après la déclaration du tableau ou dansOnInit()pour un tableau global. Le réglage reste valable pour les copies suivantes. - Travaillez sur les barres closes : l’index 0 en mode série est la barre en formation, dont la clôture change à chaque tick. Un signal calculé sur l’index 0 peut apparaître puis disparaître dans la même bougie. Basez les décisions sur l’index 1 et suivants, comme expliqué dans Coder un signal d’entrée.
- Documentez le sens dans un commentaire à côté de la déclaration : le lecteur suivant (vous dans six mois) vous en remerciera.
- Ne supposez rien sur
OnCalculate(): fixez explicitement le sens des tableaux reçus avant de les utiliser.
Pour les développeurs qui migrent un code MQL4 où Close[i] et Time[i] étaient des séries par construction, la page Remplacer les tableaux Close et Time de MQL4 détaille les équivalences.
FAQ
Pourquoi tab[0] contient-il la barre la plus ancienne après CopyClose ?
Parce qu’un tableau dynamique est indexé de gauche à droite par défaut et que les fonctions de copie stockent l’élément le plus ancien au début de la mémoire. Appelez ArraySetAsSeries(tab, true) pour que tab[0] désigne la barre en cours.
ArraySetAsSeries déplace-t-il les données en mémoire ?
Non. La documentation précise que seul le mode d’adressage change ; le stockage physique reste identique. L’opération est donc instantanée.
Peut-on utiliser ArraySetAsSeries sur un tableau statique ?
Non. Le drapeau de série ne peut pas être appliqué aux tableaux statiques ni aux tableaux multidimensionnels. Déclarez un tableau dynamique à une dimension.
Faut-il rappeler ArraySetAsSeries avant chaque CopyBuffer ?
Non, le réglage reste attaché au tableau. Un appel unique après la déclaration suffit, tant que vous ne le modifiez pas ensuite.
- Types de données en MQL5
- Variables, constantes et portée
- Paramètres input et sinput
- Opérateurs et expressions
- Conditions if, else et switch
- Boucles for, while et do while
- Écrire ses propres fonctions
- Tableaux statiques et dynamiques
- Manipuler les chaînes de caractères
- Dates, heures et fuseaux
- Structures (struct) et MqlRates, MqlTick
- Énumérations (enum) personnalisées
- #include, #define et #property
- Les fonctions événementielles
- Print, Comment, Alert : déboguer avec le journal
- NormalizeDouble et précision des prix
- SymbolInfoDouble, SymbolInfoInteger
- AccountInfoDouble : lire les informations du compte
- Bien utiliser MetaEditor
