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

MQL5 · Indicateurs

iADX en MQL5 : force de tendance, +DI, -DI et filtre de régime

Lire les trois buffers d’iADX, comprendre ce que mesurent l’ADX et les lignes directionnelles, puis construire un filtre de régime tendance/range réutilisable dans un Expert Advisor.

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

iADX(symbole, unité de temps, période) crée un handle vers l’Average Directional Movement Index de MetaTrader 5, qui expose trois buffers : 0 pour la ligne ADX (MAIN_LINE), 1 pour +DI (PLUSDI_LINE) et 2 pour -DI (MINUSDI_LINE). L’ADX mesure la force d’une tendance, pas sa direction ; la direction se lit sur la comparaison entre +DI et -DI. Ce partage des rôles en fait un excellent filtre de régime : un robot peut s’en servir pour décider s’il doit appliquer une logique de suivi de tendance, une logique de range, ou ne rien faire. C’est l’angle de cette page.

Le calcul du mouvement directionnel

L’ADX a été conçu par J. Welles Wilder. Sa construction suit plusieurs étapes, que l’on peut résumer ainsi :

  1. Pour chaque bougie, le mouvement directionnel positif (+DM) mesure de combien le plus haut a dépassé le plus haut précédent, et le mouvement directionnel négatif (-DM) de combien le plus bas est passé sous le plus bas précédent. Seul le plus grand des deux est retenu, l’autre est mis à zéro ; si aucun n’est positif, les deux valent zéro.
  2. Ces mouvements sont lissés sur N périodes puis divisés par l’amplitude moyenne des bougies (le True Range, voir iATR). On obtient +DI et -DI, exprimés en pourcentage.
  3. L’indice directionnel compare les deux lignes : plus l’écart entre +DI et -DI est grand par rapport à leur somme, plus le mouvement est orienté d’un seul côté.
  4. L’ADX est la moyenne de cet indice sur N périodes. L’aide de MetaTrader 5 l’écrit sous la forme ADX = SOMME((+DI - (-DI)) / (+DI + (-DI)), N) / N, en indiquant 14 comme période standard pour les lignes directionnelles.

L’ADX évolue entre 0 et 100. Il monte quand l’un des deux côtés domine nettement, que ce soit à la hausse ou à la baisse, et il baisse quand les deux s’équilibrent. Un ADX qui grimpe pendant une forte baisse est donc tout à fait normal : il signale une tendance baissière qui se renforce.

La fonction iADX

int iADX(
   string          symbol,       // symbole, NULL = courant
   ENUM_TIMEFRAMES period,       // unité de temps, 0 = courante
   int             adx_period    // période de calcul
);
BufferConstanteLigne
0MAIN_LINEADX
1PLUSDI_LINE+DI
2MINUSDI_LINE-DI

La fonction ne prend pas de prix appliqué : le calcul utilise toujours plus haut, plus bas et clôture. Elle renvoie INVALID_HANDLE en cas d’échec. MQL5 propose aussi iADXWilder(), qui calcule le même indicateur avec le lissage d’origine de Wilder ; les valeurs diffèrent légèrement, et les deux fonctions partagent la même numérotation de buffers d’après la table des identifiants de lignes de la documentation. Choisissez-en une et ne changez plus en cours de projet, sous peine de comparer des backtests qui ne mesurent pas la même chose.

Construire un filtre de régime

Un robot de tendance perd typiquement de l’argent en range, et un robot de retour à la moyenne en tendance. Plutôt que d’ajouter des filtres au cas par cas, on peut classer chaque bougie dans un régime et n’activer que la logique adaptée. Une règle simple à partir des trois buffers :

ConditionRégime
ADX au-dessus du seuil et en hausse, +DI > -DItendance haussière
ADX au-dessus du seuil et en hausse, -DI > +DItendance baissière
ADX sous le seuil basrange
autres casindéterminé : ne rien ouvrir

La condition « en hausse » compte autant que le niveau : un ADX à 35 qui baisse signale une tendance qui s’essouffle, souvent juste avant une phase de range. La zone intermédiaire « indéterminée » évite de basculer sans cesse d’un régime à l’autre autour d’un seuil unique.

Exemple : un EA qui classe le marché en régimes

input int    InpAdxPeriod = 14;    // période de l'ADX
input double InpTrendLvl  = 25.0;  // ADX minimum pour parler de tendance
input double InpRangeLvl  = 18.0;  // ADX maximum pour parler de range
input int    InpSlopeBars = 3;     // nombre de bougies pour mesurer la pente

enum MarketRegime { REGIME_UP, REGIME_DOWN, REGIME_RANGE, REGIME_UNKNOWN };

int hAdx = INVALID_HANDLE;

int OnInit()
  {
   if(InpRangeLvl >= InpTrendLvl) return(INIT_PARAMETERS_INCORRECT);
   hAdx = iADX(_Symbol, _Period, InpAdxPeriod);
   return(hAdx == INVALID_HANDLE ? INIT_FAILED : INIT_SUCCEEDED);
  }

void OnDeinit(const int reason) { IndicatorRelease(hAdx); }

// Classe la dernière bougie clôturée ; renvoie false si les données manquent
bool GetRegime(MarketRegime &regime)
  {
   int need = InpSlopeBars + 2;
   double adx[], pdi[], mdi[];
   ArraySetAsSeries(adx, true);
   ArraySetAsSeries(pdi, true);
   ArraySetAsSeries(mdi, true);
   if(CopyBuffer(hAdx, MAIN_LINE,    0, need, adx) < need) return(false);
   if(CopyBuffer(hAdx, PLUSDI_LINE,  0, 2,    pdi) < 2)    return(false);
   if(CopyBuffer(hAdx, MINUSDI_LINE, 0, 2,    mdi) < 2)    return(false);

   bool rising = adx[1] > adx[1 + InpSlopeBars];     // pente sur InpSlopeBars bougies
   regime = REGIME_UNKNOWN;
   if(adx[1] >= InpTrendLvl && rising)
      regime = (pdi[1] > mdi[1]) ? REGIME_UP : REGIME_DOWN;
   else if(adx[1] <= InpRangeLvl)
      regime = REGIME_RANGE;
   return(true);
  }

void OnTick()
  {
   static datetime lastBar = 0;
   static MarketRegime lastRegime = REGIME_UNKNOWN;
   datetime t = iTime(_Symbol, _Period, 0);
   if(t == lastBar) return;

   MarketRegime r;
   if(!GetRegime(r)) return;
   lastBar = t;

   if(r != lastRegime)
     {
      PrintFormat("Nouveau régime : %s", EnumToString(r));
      lastRegime = r;
     }
   // Ici : appeler la logique de tendance si REGIME_UP / REGIME_DOWN,
   // la logique de range si REGIME_RANGE, et ne rien ouvrir sinon.
  }

La fonction GetRegime() est autonome : vous pouvez la copier dans n’importe quel EA et l’appeler avant votre logique d’entrée. La lecture de plusieurs buffers d’un même handle suit le principe vu dans Handles d’indicateurs et CopyBuffer. Pour combiner ce filtre avec d’autres (horaires, spread, volatilité), voir Filtres horaires, de spread et de volatilité.

Valider le filtre avant de l’utiliser

Un filtre de régime ne vaut que s’il sépare réellement des situations différentes. Une vérification simple consiste à faire tourner l’EA sur plusieurs années dans le testeur et à compter les bougies passées dans chaque régime. Si le régime « tendance » ne représente que 3 % du temps, votre logique de tendance n’aura presque jamais l’occasion de trader et ses statistiques seront trop maigres pour être fiables. S’il en représente 70 %, le seuil est probablement trop bas et le filtre ne filtre plus rien. Une répartition de l’ordre d’un quart à un tiers du temps en tendance, conforme à ce que l’on observe habituellement sur les marchés, est un point de départ raisonnable.

Une seconde vérification compare la performance de votre stratégie de tendance avec et sans le filtre, sur la même période. Si le filtre améliore le résultat sur l’historique d’optimisation mais le dégrade sur la période suivante, il n’apporte pas d’information réelle : il a seulement appris par cœur les phases favorables de votre échantillon. Ce contrôle hors échantillon est la seule façon de distinguer un filtre utile d’un paramètre de plus.

Usages en trading algorithmique

  • Aiguillage de stratégies. Comme dans l’exemple : un même EA contient deux logiques, et l’ADX choisit laquelle est active.
  • Filtre d’un croisement de moyennes. N’accepter un croisement de moyennes mobiles que si l’ADX dépasse un seuil supprime une partie des faux signaux en range.
  • Signal directionnel de Wilder. L’aide de MT5 rappelle la règle d’origine : acheter quand +DI passe au-dessus de -DI, vendre dans le cas inverse, puis attendre que le prix dépasse l’extrême de la bougie du croisement pour confirmer l’entrée.
  • Gestion de position. Un ADX qui se retourne à la baisse après un pic peut déclencher un resserrement du stop ou une prise de bénéfice partielle.

Limites et pièges

L’ADX est un indicateur lent : il résulte de deux lissages successifs, si bien qu’il confirme une tendance bien après son démarrage. Un filtre de régime fondé sur lui fait donc rater le début des mouvements et tarde à reconnaître leur fin. Les seuils de 20 ou 25 sont des conventions ; leur pertinence varie selon le marché et l’unité de temps. Mesurez-les : comptez, sur votre historique, combien de bougies tombent dans chaque régime, et vérifiez que le régime « tendance » correspond bien à des mouvements exploitables par votre logique. Enfin, l’ADX ne voit que l’orientation, pas l’amplitude : un marché peut afficher un ADX élevé avec une volatilité trop faible pour couvrir vos coûts. Associez-le à l’ATR. L’ensemble des indicateurs de tendance est présenté dans la rubrique Indicateurs en MQL5.

Un filtre de régime réduit certaines pertes mais ne les supprime pas : un marché peut changer de régime brutalement, et le retard de l’ADX expose à des pertes au moment des transitions. Testez votre filtre sur plusieurs années et plusieurs marchés, puis en démonstration, avant tout usage réel.

FAQ

Quels sont les numéros de buffers d’iADX ?

Le buffer 0 contient l’ADX (MAIN_LINE), le buffer 1 la ligne +DI (PLUSDI_LINE) et le buffer 2 la ligne -DI (MINUSDI_LINE).

Un ADX élevé signifie-t-il que le marché monte ?

Non. L’ADX mesure la force de la tendance quel que soit son sens. La direction se lit en comparant +DI et -DI.

Quelle différence entre iADX et iADXWilder ?

iADXWilder applique le lissage d’origine de Wilder. Les valeurs diffèrent légèrement d’iADX ; choisissez l’une des deux et gardez-la tout au long du développement et des tests.

Quel seuil d’ADX utiliser ?

25 est un seuil courant pour parler de tendance et 20 pour parler de range, mais ce ne sont que des conventions. Mesurez la répartition des régimes sur votre marché avant de les adopter.

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.