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

MQL5 · Indicateurs

iAC en MQL5 : Accelerator Oscillator et règles de couleur de Williams

Lire l’Accelerator Oscillator avec iAC, le reconstruire à partir de l’AO avec iMA et coder les règles de Williams fondées sur le nombre de barres consécutives de même couleur.

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

iAC(symbole, unité de temps) crée un handle vers l’Accelerator Oscillator de Bill Williams ; comme pour l’Awesome Oscillator, la fonction n’a aucun paramètre de réglage et la documentation indique un seul buffer, d’index 0. L’AC mesure l’accélération du momentum : il change de sens avant l’AO, qui change lui-même de sens avant le prix. Ses règles d’utilisation sont originales : elles reposent sur le nombre de barres consécutives de même couleur, ce nombre dépendant de la position de l’histogramme par rapport à zéro. Cette page montre comment compter ces barres dans un robot et transformer les règles de Williams en autorisations d’achat et de vente.

Le calcul de l’Accelerator Oscillator

L’aide de MetaTrader 5 donne la formule :

  • MEDIAN PRICE = (HIGH + LOW) / 2
  • AO = SMA(MEDIAN PRICE, 5) - SMA(MEDIAN PRICE, 34)
  • AC = AO - SMA(AO, 5)

L’AC est donc l’écart entre l’Awesome Oscillator et sa propre moyenne simple sur 5 barres. Si l’AO est une mesure de vitesse (l’écart entre deux moyennes du prix), l’AC en mesure la variation : il est positif quand l’AO se situe au-dessus de sa moyenne récente, c’est-à-dire quand le momentum s’accélère, et négatif quand il ralentit. La logique de Williams est que la vitesse ralentit avant que le mouvement ne s’arrête : l’AC devrait donc signaler un essoufflement avant les autres indicateurs.

Reproduire l’AC avec iMA

Grâce au paramètre de prix appliqué d’iMA, qui accepte le handle d’un autre indicateur, vous pouvez reconstruire l’AC sans aucun calcul manuel : créez le handle de l’AO, puis une moyenne simple de 5 sur ce handle. La différence des deux buffers doit coïncider avec le buffer d’iAC(). Ce contrôle est un bon exercice pour vérifier votre maîtrise des handles, et la même technique vous permet de créer une variante avec d’autres périodes.

int hAo  = iAO(_Symbol, _Period);
int hAoM = iMA(_Symbol, _Period, 5, 0, MODE_SMA, hAo);   // SMA(AO, 5)
// AC reconstitué = buffer 0 de hAo - buffer 0 de hAoM, pour la même bougie

Les couleurs

Comme pour l’AO, une barre de l’AC est verte si elle est plus haute que la précédente et rouge si elle est plus basse. L’aide de MT5 insiste : surveiller les changements de couleur est la principale manière de lire l’indicateur. La documentation ne décrivant qu’un buffer, calculez la couleur vous-même à partir du buffer 0.

La fonction iAC

int iAC(
   string          symbol,   // symbole, NULL = courant
   ENUM_TIMEFRAMES period    // unité de temps, 0 = courante
);

La fonction renvoie INVALID_HANDLE en cas d’échec. Lisez le buffer 0 avec CopyBuffer() comme expliqué dans Handles d’indicateurs et CopyBuffer.

Les règles de Williams, traduites en conditions

L’aide de MetaTrader 5 résume les règles ainsi :

SituationAchatVente
règle généraleinterdit si la barre actuelle est rougeinterdite si la barre actuelle est verte
dans le sens de la force (AC du bon côté de zéro)2 barres vertes au-dessus de zéro2 barres rouges sous zéro
contre la force (AC du mauvais côté de zéro)3 barres vertes sous zéro3 barres rouges au-dessus de zéro
croisement de zéropas un signalpas un signal

Le point clé est la dernière ligne : contrairement à l’AO, le passage de l’AC par zéro n’est pas un signal. Ce qui compte, c’est la succession des couleurs, et l’exigence d’une barre supplémentaire quand on agit contre le côté de zéro où se trouve l’oscillateur.

Exemple : compter les barres de même couleur

L’EA suivant compte, sur les bougies clôturées, le nombre de barres consécutives de même couleur et applique la table ci-dessus. Il produit à chaque bougie une autorisation : achat permis, vente permise, ou rien.

int hAc = INVALID_HANDLE;

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

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

// Compte les barres consécutives de même couleur à partir de l'indice 1.
// color = +1 (vertes) ou -1 (rouges). Renvoie le nombre de barres.
int CountSameColor(const double &ac[], int &colorOut)
  {
   int size = ArraySize(ac);
   colorOut = 0;
   int count = 0;
   for(int i = 1; i < size - 1; i++)
     {
      int c = (ac[i] > ac[i + 1]) ? +1 : (ac[i] < ac[i + 1] ? -1 : 0);
      if(c == 0) break;                       // égalité : on arrête le décompte
      if(colorOut == 0) colorOut = c;
      if(c != colorOut) break;
      count++;
     }
   return(count);
  }

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

   double ac[];
   ArraySetAsSeries(ac, true);
   if(CopyBuffer(hAc, 0, 0, 8, ac) < 8) return;   // marge suffisante pour 3 barres + comparaison
   lastBar = t;

   int col;
   int n = CountSameColor(ac, col);
   bool above = ac[1] > 0;

   bool buyAllowed  = false;
   bool sellAllowed = false;
   if(col > 0)                                   // barres vertes
      buyAllowed = above ? (n >= 2) : (n >= 3);  // avec la force : 2, contre : 3
   if(col < 0)                                   // barres rouges
      sellAllowed = above ? (n >= 3) : (n >= 2);

   PrintFormat("AC=%.6f  %d barre(s) %s  achat=%s  vente=%s",
               ac[1], n, col > 0 ? "verte(s)" : (col < 0 ? "rouge(s)" : "-"),
               buyAllowed ? "oui" : "non", sellAllowed ? "oui" : "non");
  }

La fonction lit ac[i + 1] et s’arrête donc avant la dernière case du tableau : huit valeurs copiées laissent une marge confortable. Le test de position par rapport à zéro porte sur la dernière barre clôturée ; une variante plus stricte exigerait que toutes les barres comptées soient du même côté de zéro. Choisissez une interprétation, documentez-la dans le code et ne la changez plus pendant les tests : c’est le genre de détail qui fait diverger deux backtests d’une même « stratégie ».

Réduire le bruit avec une unité de temps supérieure

Parce que l’AC réagit à la moindre variation de momentum, ses autorisations sont plus stables quand on le lit sur une unité de temps supérieure à celle des entrées. Un EA qui entre en M15 peut ainsi créer son handle avec iAC(_Symbol, PERIOD_H1) et n’accepter un achat que si la dernière barre H1 clôturée l’autorise. Les entrées gardent leur précision, tandis que le filtre ne change d’avis qu’une fois par heure. Pensez simplement que l’indice 1 désigne alors la dernière bougie H1 clôturée, et non la dernière bougie M15 ; le détecteur de nouvelle bougie doit, lui, rester sur l’unité de temps du graphique. Mesurez dans le testeur combien d’entrées le filtre supprime : s’il en élimine la quasi-totalité, il ne filtre plus, il bloque.

Usages en trading algorithmique

  • Autorisation d’entrée. L’AC ne fournit pas de point d’entrée précis ; il dit si une entrée dans un sens est permise. Couplé à un signal d’un autre indicateur (une fractale cassée, un croisement de moyennes), il joue le rôle de filtre d’élan.
  • Interdiction à contre-élan. La règle générale (« ne pas acheter sur une barre rouge ») est la plus simple à intégrer : elle supprime les entrées au moment où le momentum ralentit.
  • Sortie anticipée. Une série de barres rouges pendant une position acheteuse peut déclencher un resserrement du stop.
  • Système de Williams complet. Williams combinait l’AC avec l’Alligator, l’AO et les fractales ; l’AC y servait à ajouter des positions quand l’accélération confirmait la tendance.

Pour combiner ces autorisations avec d’autres conditions, la page Filtres horaires, de spread et de volatilité montre comment structurer plusieurs filtres dans un EA sans multiplier les branches imbriquées.

Limites et pièges

L’AC est une dérivée de dérivée : il amplifie le bruit. Sur les petites unités de temps, les couleurs alternent souvent d’une barre à l’autre, et les séries de deux ou trois barres de même couleur sont fréquentes par simple hasard. Ses périodes (5 et 34 pour l’AO, 5 pour la moyenne) ne sont pas modifiables via iAC() ; pour d’autres réglages, utilisez la reconstruction avec iMA. Les règles de comptage contiennent des choix d’interprétation (que faire d’une égalité, quelles barres doivent être du bon côté de zéro) : deux codes différents d’une même règle peuvent donner des résultats très éloignés. Enfin, l’AC s’exprime en unités de prix, minuscules sur le forex : un seuil absolu n’a pas de sens sans normalisation. Les autres indicateurs de Bill Williams sont présentés dans la rubrique Indicateurs en MQL5.

Une accélération du momentum ne garantit pas la poursuite du mouvement. Les règles de couleur de l’Accelerator Oscillator peuvent produire des autorisations successives contradictoires. Testez toute stratégie qui les utilise sur un long historique et sur compte de démonstration avant de l’appliquer en réel.

FAQ

Combien de buffers a iAC ?

La documentation indique un seul buffer, d’index 0. Les couleurs se déduisent en comparant chaque barre à la précédente.

Le croisement de zéro de l’AC est-il un signal ?

Non. L’aide de MetaTrader 5 précise que, contrairement à l’Awesome Oscillator, le passage de l’AC par zéro n’est pas un signal. Seule la succession des couleurs compte.

Pourquoi faut-il trois barres dans certains cas ?

Quand vous agissez contre le côté de zéro où se trouve l’oscillateur (acheter alors que l’AC est sous zéro), Williams exige une barre de confirmation supplémentaire.

Peut-on modifier les périodes de l’AC ?

Pas avec iAC. Créez un handle iAO, appliquez-lui une iMA en moyenne simple, puis calculez la différence des deux buffers ; pour changer aussi 5 et 34, partez de deux iMA sur PRICE_MEDIAN.

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.