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

MQL4 · Indicateurs

iFractals en MQL4 : repérer les fractales hautes et basses

iFractals renvoie le niveau d’une fractale haute ou basse sur une bougie donnée, ou une valeur vide s’il n’y en a pas. Signature, confirmation après deux bougies, recherche de la dernière fractale et usages.

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

iFractals() renvoie en MQL4 le niveau d’une fractale de Bill Williams sur la bougie désignée par shift : le plus haut de la bougie s’il s’agit d’une fractale haute (MODE_UPPER), le plus bas s’il s’agit d’une fractale basse (MODE_LOWER). Si la bougie n’est pas une fractale, la fonction ne renvoie pas de niveau exploitable, et votre code doit le détecter. Une fractale haute est une bougie dont le plus haut dépasse ceux des deux bougies qui la précèdent et des deux qui la suivent ; elle n’est donc confirmée qu’après la clôture de deux bougies supplémentaires. Cette page explique comment lire correctement l’indicateur, retrouver la dernière fractale confirmée, et l’utiliser pour des entrées en cassure ou des stops.

La signature de iFractals

double iFractals(
   string symbol,     // symbole, NULL = symbole courant
   int    timeframe,  // unité de temps, 0 = celle du graphique
   int    mode,       // MODE_UPPER (fractale haute) ou MODE_LOWER (fractale basse)
   int    shift       // bougie examinée
);

L’exemple de la documentation officielle est iFractals(NULL, 0, MODE_UPPER, 3) : il examine la bougie 3, et ce n’est pas un hasard. La définition des fractales et leur place dans la méthode de Bill Williams sont présentées sur la page iFractals en MQL5.

Pourquoi commencer au shift 3

Une fractale compare une bougie aux deux bougies de chaque côté. Pour que la bougie examinée ait deux voisines clôturées à sa droite, elle doit se trouver au moins au shift 3 : les bougies 2 et 1 sont alors terminées, et la bougie 0 n’intervient pas. Au shift 2, la comparaison dépendrait de la bougie 0, encore en formation ; une fractale pourrait apparaître puis disparaître pendant cette bougie. Aux shifts 0 et 1, une fractale n’a tout simplement pas assez de recul.

Retenez donc qu’une fractale lue sur une bougie clôturée est connue avec deux bougies de retard. Dans un backtest, lire une fractale au shift 1 ou 2 revient à utiliser une information qui n’était pas encore disponible : les résultats paraîtront meilleurs qu’ils ne le seront en réel.

Détecter l’absence de fractale

Sur la plupart des bougies, il n’y a pas de fractale. La valeur renvoyée dans ce cas n’est pas un niveau de prix : c’est une valeur nulle ou une valeur vide. Le plus prudent est d’écrire une fonction qui accepte uniquement une valeur strictement positive et différente de la constante EMPTY_VALUE :

// Renvoie le niveau de la fractale sur la bougie 'shift', ou 0 s'il n'y en a pas
double Fractale(int mode, int shift)
{
   double v = iFractals(NULL, 0, mode, shift);
   if(v <= 0 || v == EMPTY_VALUE) return(0);
   return(v);
}

Ce double test fonctionne quel que soit le marqueur utilisé pour les bougies sans fractale, et il rend le reste du code plus lisible.

Retrouver la dernière fractale confirmée

Dans un robot, on cherche rarement à savoir si la bougie 3 précise est une fractale. On veut plutôt connaître le niveau de la dernière fractale haute ou basse pour y placer un ordre ou un stop. Il suffit de remonter les bougies à partir du shift 3 :

// Niveau de la dernière fractale confirmée, recherchée sur 'profondeur' bougies
double DerniereFractale(int mode, int profondeur, int &shiftTrouve)
{
   shiftTrouve = -1;
   for(int i = 3; i < 3 + profondeur && i < Bars; i++)
   {
      double v = Fractale(mode, i);
      if(v > 0) { shiftTrouve = i; return(v); }
   }
   return(0);                                       // aucune fractale dans la fenêtre
}

Le paramètre profondeur borne la recherche : sur un marché en tendance forte, une fractale basse peut ne pas apparaître pendant des dizaines de bougies. Le shift trouvé, renvoyé par référence, permet de savoir à quelle bougie elle correspond et de dater la fractale avec Time[shiftTrouve].

Exemple complet : entrée en cassure de la dernière fractale haute

L’EA ci-dessous place un ordre d’achat stop quelques points au-dessus de la dernière fractale haute confirmée, avec un stop loss sous la dernière fractale basse. À chaque nouvelle bougie, il supprime l’ordre en attente devenu obsolète et le replace sur les niveaux à jour.

#property strict

input int    Profondeur = 50;     // bougies examinées pour trouver les fractales
input int    MargePts   = 20;     // marge au-delà de la fractale, en points
input double Lots       = 0.10;
input int    Magic      = 41011;

datetime derniereBougie = 0;

double Fractale(int mode, int shift)
{
   double v = iFractals(NULL, 0, mode, shift);
   if(v <= 0 || v == EMPTY_VALUE) return(0);
   return(v);
}

double DerniereFractale(int mode, int &shiftTrouve)
{
   shiftTrouve = -1;
   for(int i = 3; i < 3 + Profondeur && i < Bars; i++)
   {
      double v = Fractale(mode, i);
      if(v > 0) { shiftTrouve = i; return(v); }
   }
   return(0);
}

void OnTick()
{
   if(Time[0] == derniereBougie) return;
   derniereBougie = Time[0];

   // Une position déjà ouverte : on ne place rien
   for(int i = OrdersTotal() - 1; i >= 0; i--)
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && OrderSymbol() == Symbol()
         && OrderMagicNumber() == Magic && OrderType() == OP_BUY) return;

   // Supprimer l'ordre en attente précédent
   for(int i = OrdersTotal() - 1; i >= 0; i--)
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && OrderSymbol() == Symbol()
         && OrderMagicNumber() == Magic && OrderType() == OP_BUYSTOP)
         if(!OrderDelete(OrderTicket())) Print("OrderDelete : erreur ", GetLastError());

   int sH, sB;
   double haut = DerniereFractale(MODE_UPPER, sH);
   double bas  = DerniereFractale(MODE_LOWER, sB);
   if(haut == 0 || bas == 0) return;

   double entree = NormalizeDouble(haut + MargePts * Point, Digits);
   double sl     = NormalizeDouble(bas - MargePts * Point, Digits);
   double minDist = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
   if(entree <= Ask + minDist) return;              // trop proche du prix actuel

   if(OrderSend(Symbol(), OP_BUYSTOP, Lots, entree, 0, sl, 0, "Fractale", Magic, 0, clrBlue) < 0)
      Print("OrderSend BUYSTOP : erreur ", GetLastError());
}

Un ordre d’achat stop doit être placé au-dessus du prix actuel d’au moins la distance minimale du courtier, d’où le test sur MODE_STOPLEVEL. Le fonctionnement des ordres en attente est détaillé dans Ordres en attente, et leur suppression dans OrderDelete.

Fractales et structure de marché

Au-delà des cassures, les fractales offrent une façon simple de décrire la structure du marché dans un robot. Une suite de fractales hautes de plus en plus hautes et de fractales basses de plus en plus hautes caractérise une tendance haussière ; l’inverse caractérise une tendance baissière. Avec la fonction de recherche de cette page, il suffit de retrouver les deux dernières fractales de chaque type et de les comparer. Cette lecture ne dépend d’aucune période de moyenne et s’adapte d’elle-même à la volatilité, puisque les fractales suivent les extrêmes réels du prix.

Elle a toutefois deux limites. D’abord, le retard de deux bougies s’applique à chaque fractale, si bien que le changement de structure n’est détecté qu’après coup. Ensuite, la notion de « plus haut » ou « plus bas » ne tient pas compte de l’amplitude : une fractale à peine supérieure à la précédente compte autant qu’une nette progression. Ajouter une marge minimale, exprimée en points ou en fraction d’ATR, rend la règle plus robuste face au bruit.

Usages et pièges en trading

  • Stop sous la dernière fractale basse : c’est une alternative simple au stop fixe. Le niveau correspond à un creux local identifiable sur le graphique, mais sa distance varie beaucoup : adaptez la taille de position en conséquence.
  • Fractales trop nombreuses : sur des unités de temps courtes, les fractales apparaissent toutes les quelques bougies et perdent leur valeur de repère. Les fractales d’une unité de temps supérieure, lues avec iFractals(NULL, PERIOD_H4, ...), sont plus significatives.
  • Biais d’anticipation : ne lisez jamais une fractale en dessous du shift 3 dans une règle d’entrée. C’est l’erreur la plus fréquente et la plus flatteuse en backtest.
  • Égalités : quand deux bougies voisines ont exactement le même plus haut, la détection peut différer de votre intuition visuelle. Vérifiez sur le graphique quelques cas avant de vous fier au code.

Les autres indicateurs de la plateforme sont présentés dans la rubrique Indicateurs en MQL4.

Une cassure de fractale peut échouer et revenir aussitôt dans la fourchette. Protégez chaque position par un stop loss et validez la stratégie sur compte de démonstration avant tout usage réel.

FAQ

Que renvoie iFractals quand il n’y a pas de fractale ?

La fonction ne renvoie pas de niveau de prix exploitable. Testez la valeur : considérez qu’il n’y a pas de fractale si elle est nulle ou égale à EMPTY_VALUE, comme dans la fonction Fractale() de cette page.

Pourquoi lire les fractales à partir du shift 3 ?

Une fractale compare une bougie à ses deux voisines de chaque côté. Au shift 3, les deux bougies de droite sont clôturées et la fractale est définitive. En dessous, elle dépend de bougies non terminées.

Quelles constantes utiliser pour le paramètre mode ?

MODE_UPPER pour les fractales hautes et MODE_LOWER pour les fractales basses. Utilisez les noms des constantes plutôt que leurs valeurs numériques.

Peut-on utiliser iFractals sur un autre symbole ?

Oui, en passant le nom du symbole au premier paramètre. Pensez alors à utiliser les tableaux de prix de ce symbole, par exemple avec iHigh() et iLow(), et non High[] et Low[] qui concernent le graphique courant.

Les fractales repeignent-elles ?

Une fractale lue sur une bougie au shift 3 ou plus est définitive. En revanche, une fractale affichée sur le graphique à la bougie 2 peut disparaître si la bougie en cours dépasse son extrême ; c’est pourquoi le code ne doit pas lire ces bougies.

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.