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

MQL5 · Indicateurs

iFractals en MQL5 : EMPTY_VALUE, confirmation et stops sous les fractales

Lire les fractales de Bill Williams avec iFractals, gérer EMPTY_VALUE et le délai de confirmation, puis exploiter la dernière fractale confirmée pour un stop ou une cassure.

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

iFractals(symbole, unité de temps) crée un handle vers l’indicateur Fractals de Bill Williams, qui expose deux buffers : 0 pour les fractales hautes (UPPER_LINE) et 1 pour les fractales basses (LOWER_LINE). Contrairement aux autres indicateurs, ses buffers sont presque vides : une valeur n’existe que sur les bougies qui forment une fractale, et toutes les autres contiennent EMPTY_VALUE. De plus, une fractale ne peut être confirmée qu’après la clôture de deux bougies supplémentaires. Ces deux particularités, valeurs vides et délai de confirmation, sont la source de la plupart des bugs des robots qui utilisent les fractales. Cette page explique comment les gérer, puis comment exploiter la dernière fractale confirmée pour placer un stop ou détecter une cassure.

Qu’est-ce qu’une fractale ?

L’aide de MetaTrader 5 définit une fractale haute comme une série d’au moins cinq bougies consécutives dont la bougie centrale a le plus haut le plus élevé, avec deux plus hauts inférieurs de chaque côté. La fractale basse est la configuration inverse : la bougie centrale a le plus bas le plus bas, entourée de deux plus bas supérieurs de chaque côté. Les fractales marquent donc des sommets et creux locaux ; sur le graphique, elles apparaissent sous forme de flèches au-dessus ou en dessous de la bougie centrale.

Cette définition a une conséquence directe : pour savoir si une bougie est une fractale, il faut connaître les deux bougies qui la suivent. Une fractale n’est donc jamais connue au moment où elle se forme, mais deux bougies plus tard.

La fonction iFractals

int iFractals(
   string          symbol,   // symbole, NULL = courant
   ENUM_TIMEFRAMES period    // unité de temps, 0 = courante
);
BufferConstanteContenu
0UPPER_LINEprix de la fractale haute, ou EMPTY_VALUE
1LOWER_LINEprix de la fractale basse, ou EMPTY_VALUE

La fonction n’a aucun paramètre de réglage et renvoie INVALID_HANDLE en cas d’échec. Les valeurs se lisent avec CopyBuffer() comme décrit dans Handles d’indicateurs et CopyBuffer.

Le piège d’EMPTY_VALUE

La page de référence de la fonction ne le mentionne pas, mais les bougies sans fractale contiennent la constante EMPTY_VALUE ; un administrateur de MetaQuotes l’a confirmé sur le forum MQL5 en le qualifiant de comportement normal. Or EMPTY_VALUE n’est pas zéro : c’est le plus grand nombre représentable en double précision. Un code qui cherche « la fractale la plus basse » sans filtrer cette valeur, ou qui place un stop sur up[i] sans vérification, enverra un prix absurde au serveur. La règle est absolue : testez toujours valeur != EMPTY_VALUE avant d’utiliser une valeur de fractale. Par prudence, vous pouvez aussi ignorer les valeurs nulles ou négatives.

Le délai de confirmation

Avec des tableaux indexés en série, l’indice 0 est la bougie en cours et l’indice 1 la dernière bougie clôturée. Pour qu’une fractale à l’indice i soit confirmée, les deux bougies suivantes (i – 1 et i – 2) doivent être clôturées, donc i – 2 doit valoir au moins 1. Une fractale n’est définitive qu’à partir de l’indice 3. À l’indice 2, une flèche peut apparaître pendant la formation de la bougie en cours puis disparaître si celle-ci dépasse le sommet : c’est le phénomène de « repaint » souvent reproché aux fractales. Un robot ne doit lire que les indices 3 et au-delà.

Exemple : trouver la dernière fractale confirmée

L’EA suivant cherche, à chaque nouvelle bougie, la fractale haute et la fractale basse confirmées les plus récentes. Il en déduit un niveau de stop pour une position acheteuse (sous la dernière fractale basse) et détecte la cassure de la dernière fractale haute par une clôture.

input int InpLookback = 100;   // nombre de bougies explorées

int hFr = INVALID_HANDLE;

int OnInit()
  {
   hFr = iFractals(_Symbol, _Period);
   return(hFr == INVALID_HANDLE ? INIT_FAILED : INIT_SUCCEEDED);
  }

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

// Cherche la fractale confirmée la plus récente dans le buffer indiqué.
// Renvoie true et remplit price/shift si une fractale est trouvée.
bool LastFractal(int buffer, double &price, int &shift)
  {
   double v[];
   ArraySetAsSeries(v, true);
   int n = CopyBuffer(hFr, buffer, 0, InpLookback, v);
   if(n < 4) return(false);
   for(int i = 3; i < n; i++)                  // indice 3 minimum : fractale confirmée
     {
      if(v[i] != EMPTY_VALUE && v[i] > 0.0)
        {
         price = v[i];
         shift = i;
         return(true);
        }
     }
   return(false);
  }

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

   double upPrice, downPrice;
   int    upShift, downShift;
   if(!LastFractal(UPPER_LINE, upPrice, upShift))     return;
   if(!LastFractal(LOWER_LINE, downPrice, downShift)) return;
   lastBar = t;

   int    digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   double close1 = iClose(_Symbol, _Period, 1);
   double close2 = iClose(_Symbol, _Period, 2);

   // Stop d'un achat : quelques points sous la dernière fractale basse
   double buyStop = NormalizeDouble(downPrice - 5 * _Point, digits);

   // Cassure : la dernière bougie clôture au-dessus de la fractale haute, la précédente non
   bool breakout = close2 <= upPrice && close1 > upPrice;

   PrintFormat("Fractale haute %s (il y a %d bougies) | basse %s (il y a %d) | stop achat %s%s",
               DoubleToString(upPrice, digits), upShift,
               DoubleToString(downPrice, digits), downShift,
               DoubleToString(buyStop, digits),
               breakout ? " | CASSURE HAUSSIÈRE" : "");
  }

La recherche démarre à l’indice 3 et s’arrête à la première valeur valide : vous obtenez la fractale confirmée la plus récente, jamais une fractale susceptible de disparaître. La marge de cinq points sous la fractale basse évite que le stop soit placé exactement sur un niveau que le marché vient souvent retester ; adaptez-la au spread du symbole. Avant d’envoyer ce stop, vérifiez qu’il respecte la distance minimale du courtier, comme expliqué dans Placer et modifier stop loss et take profit.

Vérifier l’absence de repaint dans le testeur

Le meilleur moyen de s’assurer qu’un EA n’exploite pas des fractales non confirmées est de comparer deux backtests : l’un en mode « prix d’ouverture uniquement », l’autre en ticks réels. Si votre logique ne lit que des fractales à partir de l’indice 3, évaluées à l’ouverture de chaque bougie, les deux tests doivent produire des signaux identiques aux mêmes bougies, aux différences d’exécution près. Un écart important dans le nombre de transactions signale presque toujours une lecture de l’indice 2 ou une décision prise en cours de bougie. Ce contrôle est rapide et protège d’un des pièges les plus coûteux : un backtest flatteur fondé sur des niveaux que le robot n’aurait jamais connus à temps en conditions réelles.

Usages en trading algorithmique

  • Placement de stops. La dernière fractale basse est un niveau de stop naturel pour un achat, la dernière fractale haute pour une vente : ce sont les derniers points où le marché a fait demi-tour.
  • Trailing stop par paliers. À chaque nouvelle fractale basse confirmée plus haute que la précédente, le stop d’un achat remonte sous elle. Le stop progresse ainsi au rythme de la structure du marché.
  • Cassure. Une clôture au-delà de la dernière fractale haute signale que le dernier sommet local est dépassé ; c’est la base de nombreuses stratégies de breakout. Un ordre stop placé quelques points au-dessus de la fractale permet d’entrer sans attendre la clôture.
  • Filtre par l’Alligator. L’aide de MT5 recommande de filtrer les fractales avec les dents de l’Alligator : une fractale haute située sous les dents ne devrait pas déclencher d’achat.

Limites et pièges

Le délai de confirmation de deux bougies est incompressible : un stop placé sous une fractale l’est toujours avec retard sur la structure réelle du marché. Les fractales sont très nombreuses sur les petites unités de temps, où beaucoup ne correspondent qu’au bruit ; lire les fractales d’une unité de temps supérieure, en créant le handle avec PERIOD_H1 ou PERIOD_H4, donne des niveaux plus significatifs. La définition stricte (deux bougies de chaque côté) traite mal les égalités de plus hauts, fréquentes sur les instruments à faible nombre de décimales : selon les cas, deux sommets égaux peuvent ne produire aucune fractale. Enfin, une fractale ancienne peut rester « la dernière » pendant longtemps en tendance forte ; limitez la recherche avec un paramètre comme InpLookback et décidez de ce que fait l’EA quand aucune fractale récente n’existe. Les autres indicateurs de Bill Williams sont présentés dans la rubrique Indicateurs en MQL5.

Un stop placé sous une fractale peut être franchi par un gap ou un glissement, et une cassure de fractale peut échouer immédiatement. Ce code journalise des niveaux sans passer d’ordres. Avant tout usage réel, testez en ticks réels dans le Strategy Tester puis sur compte de démonstration.

FAQ

Que contient le buffer d’iFractals quand il n’y a pas de fractale ?

La constante EMPTY_VALUE, qui n’est pas zéro mais une valeur très grande. Testez toujours valeur != EMPTY_VALUE avant d’utiliser un prix de fractale.

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

Le buffer 0 (UPPER_LINE) contient les fractales hautes et le buffer 1 (LOWER_LINE) les fractales basses.

Pourquoi une fractale apparaît puis disparaît-elle ?

Une fractale n’est confirmée qu’après la clôture des deux bougies qui suivent la bougie centrale. Tant que ce n’est pas le cas, la bougie en cours peut invalider le sommet. Dans un EA, ne lisez que les fractales à partir de l’indice 3.

Peut-on utiliser les fractales d’une autre unité de temps ?

Oui : créez le handle avec l’unité de temps souhaitée en second paramètre. Les indices comptent alors des bougies de cette unité de temps, et la règle de l’indice 3 s’applique à elles.

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.