Un fichier include .mqh d'outils pour les indicateurs

Après un fichier de fonctions pour les calculs temporels et les calculs sur les cotations, que nous étofferons par la suite, nous allons faire un fichier pour nous faciliter la tache lors de la création d'indicateurs. Il n'y aura que deux fonctions pour l'instant, très simples algorithmiquement, elles nous soulageront des nombreuses lignes de codes à répéter pour créer des indicateurs. Et les valeurs par défaut nous éviteront de les préciser à chaque fois.

Ce que fait un indicateur:

Un indicateur va chercher les valeurs du cours dans l'historique et fait des calculs pour donner un résultat chiffré par période. Ce résultat doit être stocké dans un historique spécialement créé pour l'indicateur, et MetaTrader se sert de cet historique pour tracer une courbe ou un histogramme correspondant à l'évolution de notre valeur calculée. La courbe ainsi créée se rajoute au cours sur le graphique pour nous donner l'évolution de notre valeur. C'est cette valeur qui va nous donner des indications pour trader, ou bien qui va servir à des experts advisors pour prendre des décisions.

Les initialisations nécessaires

L'historique de cet indicateur est simplement un tableau, dont la taille est gérée par MetaTrader. Nous n'avons qu'à déclarer son existence et le remplir. MetaTrader doit, pour effectuer ce travail, être averti de certaines choses. Pour l'indicateur globalement:

• Donner un nom à l'indicateur.
• Fixer la précision de l'indicateur: le nombre de décimales.

Dans chaque indicateur il peut y avoir jusqu'à huit valeurs basées sur huit calculs différents avec chacune leur historique. Chaque valeur calculée avec son historique est appelée un index. Pour chacun des huit index possibles, il faut:

• Préciser le tableau à utiliser pour l'historique.
• Fixer le décalage entre les périodes de l'indicateur et celle du cours.
• Fixer le style graphique pour le traçage de la valeur.
• Préciser la période de début de traçage.
• Préciser le label à afficher pour l'index.
• Préciser la valeur signifiant aucune donnée pour la période.

Une fonction d'initialisation de l'indicateur

Nous devons préciser à MetaTrader le nombre de décimales que l'indicateur doit fournir, en général, le même nombre de décimales que celui de la paire sur laquelle il s'exécute. Nous utilisons donc la fonction  MarketInfo()  qui va nous donner cette information grâce aux paramètres  Symbol()  qui donne le nom de la paire de devises courante. (sur laquelle on est) et  MODE_DIGITS  qui est un code signifiant à la fonction  MarketInfo()  qu'on veut le nombre de décimales (digits). Et ce nombre de décimales est fourni à la fonction  IndicatorDigits()  qui va le fixer pour notre indicateur.

string paireCourante = Symbol();
int nombreDecimales = MarketInfo(paireCourante, MODE_DIGITS);
IndicatorDigits(nombreDecimales);

On doit également donner un nom court à l'indicateur, utilisable par MetaTrader notamment pour l'afficher dans les graphiques et pour être appelé par un expert advisor. Ce nom on le donne à la fonction IndicatorShortName() qui va le fixer pour cet indicateur.

IndicatorShortName(nomCourt);

La fonction d'initialisation de l'indicateur reçoit alors juste le nom court de l'indicateur et exécute les lignes de code précédentes. Elle ne retourne aucune valeur, elle est donc du type void:

void initIndicateur(string nomCourt) {
   string paireCourante = Symbol();
   int nombreDecimales = MarketInfo(paireCourante, MODE_DIGITS);
   IndicatorDigits(nombreDecimales);
   IndicatorShortName(nomCourt);
}

Une fonction d'initialisation d'un index

L'initialisation d'un index doit indiquer le numéro de l'index sur les huit possibles: de 0 à 7. Il faut donc transmettre ce numéro en argument à la fonction et le fournir à toutes les fonctions que nous allons appeler pour paramétrer cet index.
Nous devons déclarer le tableau qui nous sert d'historique pour l'indicateur, il y a en au moins un. Nous pouvons en créer jusqu'à huit par indicateur. Pour ces déclarations, nous ne précisons pas la taille du tableau, MetaTrader s'en chargera. Cette déclaration de tableau sera faite manuellement pour chaque indicateur, car nous ne pouvons pas retourner un tableau avec une fonction, donc pas de déclaration de ces tableaux dans une fonction. Nous devrons par contre passer le tableau à la fonction et par référence (pas de copie) pour qu'elle puisse passer cette référence à MetaTrader qui saura alors quel tableau utiliser pour l'historique. C'est la fonction SetIndexBuffer() qui transmet la référence.

SetIndexBuffer(noIndex, tamponHistorique);

Nous devons ensuite régler le décalage de l'indicateur par rapport aux périodes des courts. C'est-à-dire le décalage voulu entre la valeur calculée pour une période et la période qu'elle représente. Normalement il n'y en a pas, on calcule une valeur pour une période et cette valeur ressort quand on demande cette période précisément. Mais on peut vouloir décaler toutes les valeurs de chaque période pour avancer ou reculer le signal par rapport aux cotations de la paire. Ce décalage est fourni en argument, sans valeur par défaut, car elle peut être modifiée à chaque initialisation de l'indicateur. On doit donc la transmettre à chaque fois:

SetIndexShift(noIndex, decalagePeriodes);

Le calcul d'une valeur d'index pour une période, demande presque tout le temps d'utiliser les cours antérieurs à la période calculée. Or pour la toute première période et les quelques suivantes de l'historique, il n'y a pas suffisamment de cotations antérieures pour faire ce calcul. On ne doit donc pas tracer l'indicateur pour ces toutes premières périodes car s'il on y calcule des valeurs, elles ne seront pas bonnes par manque de cotations antérieures. On peut préciser à MetaTrader de ne pas tracer l'index pour un certain nombre de périodes au début de l'historique:

SetIndexDrawBegin(noIndex, debutTracage);

Pour afficher le nom de l'index lorsqu'on pointe dessus avec la souris, ou pour avoir un intitulé dans la fenêtre de description, on peut assigner un label à un index:

SetIndexLabel(noIndex, intitule);

Ensuite, on peut, et c'est conseillé de donner un style de traçage à l'index. On peut modifier

• le mode (ligne, section, histogramme, flèches, zigzag, remplissage ou aucun traçage).
• le style du tracé (continu, traits interrompus, points, trait-point et trait-point-point).
• l'épaisseur du trait en pixel (de 1 à 5) ou EMPTY pour aucun changement d'épaisseur.
• la couleur (clrNONE pour aucun changement de couleur).

SetIndexStyle(noIndex, modeTracage, style, epaisseur, couleur);

Pour finir, il faut indiquer la valeur vide à utiliser pour signaler à MetaTrader qu'il n'y a pas de valeur calculée dans une période, lui indiquant ainsi qu'il ne faut pas tracer pour cette période. Cette valeur vide par défaut pour chaque index est  EMPTY_VALUE . On la reçoit en argument avec cette valeur par défaut.

SetIndexEmptyValue(noIndex, valeurVide);

La fonction d'initialisation de l'index reçoit tous ces paramètres et exécute les lignes de code précédentes. Elle ne retourne aucune valeur, elle est donc du type void:

void initIndex(int noIndex, double &tamponHistorique[], int decalagePeriodes,
               int debutTracage=0, string intitule="",
               color couleur=clrNONE, int style=STYLE_SOLID,
               int modeTracage=DRAW_LINE, int epaisseur=EMPTY,
               double valeurVide=EMPTY_VALUE) {
   SetIndexBuffer(noIndex, tamponHistorique);
   SetIndexShift(noIndex, decalagePeriodes);
   SetIndexDrawBegin(noIndex, debutTracage);
   SetIndexLabel(noIndex, intitule);
   SetIndexStyle(noIndex, modeTracage, style, epaisseur, couleur);
   SetIndexEmptyValue(noIndex, valeurVide);
}

Le tutoriel vidéo et le code complet de l'include

Voici le fichier include «OutilsIndicateurs.mqh» que nous créons dans sa première version:

//+------------------------------------------------------------------+
//|                                            OutilsIndicateurs.mqh |
//|                  Copyright 2014, argent-facile-avec-robots-forex |
//|               http://argent-facile-avec-robots-forex.blogspot.fr |
//+------------------------------------------------------------------+
#property copyright "Copyright 2014, argent-facile-avec-robots-forex"
#property  link  "http://argent-facile-avec-robots-forex.blogspot.fr"
#property  strict
//+------------------------------------------------------------------+
//| Defines                                                          |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Constantes                                                       |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Fonctions d'initialisation                                       |
//+------------------------------------------------------------------+

void initIndicateur(string nomCourt) {
   string paireCourante = Symbol();
   int nombreDecimales = MarketInfo(paireCourante, MODE_DIGITS);
   IndicatorDigits(nombreDecimales);
   IndicatorShortName(nomCourt);
}

void initIndex(int noIndex, double &tamponHistorique[], int decalagePeriodes,
               int debutTracage=0, string intitule="",
               color couleur=clrNONE, int style=STYLE_SOLID,
               int modeTracage=DRAW_LINE, int epaisseur=EMPTY,
               double valeurVide=EMPTY_VALUE) {
   SetIndexBuffer(noIndex, tamponHistorique);
   SetIndexShift(noIndex, decalagePeriodes);
   SetIndexDrawBegin(noIndex, debutTracage);
   SetIndexLabel(noIndex, intitule);
   SetIndexStyle(noIndex, modeTracage, style, epaisseur, couleur);
   SetIndexEmptyValue(noIndex, valeurVide);
}

//+------------------------------------------------------------------+

Et voilà de quoi nous soulager pour programmer des indicateurs ! Nous allons évidemment tester ce code dès le prochain post pour garantir que le tout fonctionne !