MQL5 · Indicateurs
iMFI en MQL5 : le Money Flow Index et la détection de divergences
iMFI() calcule le Money Flow Index, un oscillateur de 0 à 100 qui combine prix typique et volume. Signature, calcul, choix du volume et code de divergence.
Pour lire le Money Flow Index dans un programme MQL5, créez un handle avec iMFI(symbol, period, ma_period, applied_volume) puis copiez le buffer 0 avec CopyBuffer(). Le MFI est souvent présenté comme un « RSI pondéré par le volume » : il oscille entre 0 et 100, et ses zones extrêmes (80 et 20 dans l’exemple de la documentation officielle) signalent des excès possibles. Cette page se concentre sur ce qui le distingue réellement du RSI et sur son usage le plus intéressant en algorithmique : la divergence entre le prix et le flux monétaire.
La signature d’iMFI
int iMFI(
string symbol, // symbole, NULL = symbole courant
ENUM_TIMEFRAMES period, // unité de temps, 0 = courante
int ma_period, // période de calcul, en bougies
ENUM_APPLIED_VOLUME applied_volume // VOLUME_TICK ou VOLUME_REAL
);
La fonction renvoie un handle, ou INVALID_HANDLE en cas d’échec. Notez ce qui manque par rapport à iRSI() : il n’y a pas de paramètre de prix appliqué. Le MFI travaille toujours sur le prix typique de la bougie, et le seul choix qui vous est laissé concerne le type de volume. L’exemple de la documentation utilise une période de 14 et VOLUME_TICK.
Comment le terminal calcule le MFI
L’aide de MetaTrader 5 décompose le calcul en cinq étapes :
- prix typique :
TP = (HIGH + LOW + CLOSE) / 3; - flux monétaire de la bougie :
MF = TP × VOLUME; - le flux est compté comme positif si le prix typique monte par rapport à la bougie précédente, négatif s’il baisse ; on additionne séparément flux positifs et négatifs sur la période ;
- ratio monétaire :
MR = flux positif / flux négatif; MFI = 100 - 100 / (1 + MR).
La structure finale est exactement celle du RSI. La différence tient à ce qui est additionné : le RSI additionne des variations de prix, le MFI additionne des montants de flux (prix × volume), dont le signe dépend seulement de la direction du prix typique. Une petite hausse sur un gros volume pèse donc lourd dans le MFI, alors qu’elle compte peu dans le RSI. C’est ce qui rend les deux oscillateurs complémentaires : quand ils divergent l’un de l’autre, c’est le volume qui raconte une histoire différente du prix.
Le choix du volume, décision structurante
Avec VOLUME_TICK, le flux est pondéré par le nombre de changements de cotation, une approximation de l’activité disponible sur presque tous les symboles. VOLUME_REAL n’a de sens que si le serveur diffuse le volume échangé, ce qui concerne principalement les marchés organisés. Un détail pratique : si le volume vaut zéro sur toute la fenêtre, flux positif et négatif sont nuls et l’indicateur ne peut rien mesurer. Avant de lancer une optimisation, affichez le MFI sur le graphique avec les deux réglages et vérifiez que la courbe bouge.
Gardez aussi à l’esprit que le volume en ticks dépend du flux de cotations du serveur. Deux courtiers peuvent produire des MFI légèrement différents sur le même instrument, ce qui n’est pas le cas d’un RSI calculé sur les clôtures.
Exemple complet : détecter une divergence haussière prix/MFI
L’aide de MetaTrader 5 souligne que, lorsque le prix et le MFI évoluent en sens opposé, la probabilité d’un retournement augmente. Le script d’Expert Advisor suivant formalise une version simple et testable de cette idée : le prix fait un plus bas plus bas que lors de la fenêtre précédente, alors que le MFI, lui, fait un plus bas plus haut, et ce plus bas du MFI se situe sous la zone des 20.
//+------------------------------------------------------------------+
//| MfiDivergence.mq5 - divergence haussière entre le prix et le MFI |
//+------------------------------------------------------------------+
input int InpMfiPeriod = 14; // période du MFI
input ENUM_APPLIED_VOLUME InpVolume = VOLUME_TICK; // type de volume
input int InpRecent = 5; // fenêtre récente (bougies)
input int InpOlder = 20; // fenêtre de référence
input double InpLowZone = 20.0; // zone de survente
int hMfi = INVALID_HANDLE;
int OnInit()
{
hMfi = iMFI(_Symbol, PERIOD_CURRENT, InpMfiPeriod, InpVolume);
if(hMfi == INVALID_HANDLE)
{
PrintFormat("iMFI : échec de création, erreur %d", GetLastError());
return(INIT_FAILED);
}
return(INIT_SUCCEEDED);
}
void OnDeinit(const int reason)
{
if(hMfi != INVALID_HANDLE)
IndicatorRelease(hMfi);
}
//--- index du minimum d'un tableau entre from et to inclus
int IndexOfMin(const double &a[], int from, int to)
{
int best = from;
for(int i = from + 1; i <= to; i++)
if(a[i] < a[best])
best = i;
return(best);
}
//--- true si une divergence haussière est détectée sur bougies closes
bool BullishDivergence()
{
int total = 1 + InpRecent + InpOlder; // l'index 0 (bougie en cours) est ignoré
double mfi[], low[];
ArraySetAsSeries(mfi, true);
ArraySetAsSeries(low, true);
if(CopyBuffer(hMfi, 0, 0, total, mfi) < total) return(false);
if(CopyLow(_Symbol, PERIOD_CURRENT, 0, total, low) < total) return(false);
int r = IndexOfMin(low, 1, InpRecent); // creux récent du prix
int o = IndexOfMin(low, InpRecent + 1, total - 1); // creux plus ancien
bool priceLowerLow = low[r] < low[o];
bool mfiHigherLow = mfi[r] > mfi[o];
bool fromOversold = mfi[o] < InpLowZone;
return(priceLowerLow && mfiHigherLow && fromOversold);
}
void OnTick()
{
static datetime lastBar = 0;
datetime bar = iTime(_Symbol, PERIOD_CURRENT, 0);
if(bar == lastBar) return;
lastBar = bar;
if(BullishDivergence())
PrintFormat("%s : divergence haussière prix/MFI détectée", _Symbol);
}
La logique compare les mêmes bougies des deux côtés : on repère les creux sur la série des plus bas, puis on lit la valeur du MFI sur ces bougies précises. C’est plus robuste que de chercher séparément le minimum du prix et le minimum du MFI, qui peuvent tomber sur des bougies sans rapport entre elles. Les deux tableaux sont indexés en série pour que l’index 1 désigne, dans les deux cas, la dernière bougie clôturée. Le symétrique baissier se code en remplaçant les plus bas par les plus hauts, les minimums par des maximums et la zone 20 par la zone 80.
Seuils, période et unité de temps
Les niveaux 20 et 80 retenus par l’exemple officiel sont des repères, pas des constantes. Sur un instrument très directionnel, le MFI peut rester au-dessus de 80 pendant des dizaines de bougies : vendre à chaque franchissement serait alors une stratégie contre-tendance coûteuse. Dans un Expert Advisor, déclarez ces seuils en paramètres input pour pouvoir les tester, et méfiez-vous des réglages trop fins issus d’une optimisation : un seuil optimal à 23,5 sur un historique a peu de chances de le rester. La page Optimisation génétique explique comment encadrer ce type de recherche.
La période agit comme pour le RSI : plus elle est courte, plus le MFI touche souvent les extrêmes. Si vous construisez un signal de divergence, la période doit rester cohérente avec la taille de vos fenêtres de comparaison ; un MFI à 14 périodes comparé sur des fenêtres de 3 bougies réagit surtout au bruit.
Pièges fréquents
- Lire la bougie en cours.
mfi[0]évolue à chaque tick ; un creux détecté sur la bougie en cours peut disparaître avant la clôture. Basez vos signaux sur l’index 1 et au-delà. - Oublier que les données peuvent manquer. Juste après le chargement de l’EA ou lors d’un changement d’unité de temps,
CopyBuffer()peut renvoyer moins d’éléments que demandé. La fonction ci-dessus renvoie alorsfalseet le signal est simplement reporté. - Utiliser le MFI comme déclencheur unique. Une divergence signale un essoufflement, pas un point d’entrée précis. Combinez-la avec un déclencheur de prix (cassure d’un plus haut récent, par exemple) et un filtre de tendance.
- Comparer des MFI de courtiers différents. Le volume en ticks varie d’un serveur à l’autre ; vos résultats de test n’ont de valeur que sur le flux de données que vous utiliserez en réel.
Si vous cherchez plutôt un indicateur de volume cumulé pour confirmer des cassures, la page iOBV : On Balance Volume traite ce cas. Pour situer le MFI parmi les autres oscillateurs disponibles, revenez à la rubrique Indicateurs en MQL5.
FAQ
Quelle est la différence entre iMFI et iRSI ?
Les deux ont la même formule finale (100 - 100 / (1 + ratio)), mais le RSI additionne des variations de prix de clôture alors que le MFI additionne des flux monétaires, c’est-à-dire le prix typique multiplié par le volume. iMFI() n’a donc pas de paramètre de prix appliqué, mais un paramètre de type de volume.
Pourquoi mon MFI reste-t-il plat ou à une valeur constante ?
Le plus souvent, le volume choisi est nul sur le symbole : c’est typique de VOLUME_REAL sur un instrument dont le serveur ne diffuse pas de volume échangé. Passez à VOLUME_TICK et vérifiez la fenêtre de données.
Combien de buffers renvoie iMFI ?
Un seul, d’index 0, qui contient la valeur du MFI entre 0 et 100. Il se lit avec CopyBuffer(handle, 0, ...).
Peut-on utiliser le MFI d’une autre unité de temps dans un EA ?
Oui : passez l’unité de temps voulue en deuxième paramètre, par exemple PERIOD_H4. Attention alors à l’indexation : l’index 1 désigne la dernière bougie H4 clôturée, pas la dernière bougie de votre graphique.
- Handles d’indicateurs et CopyBuffer
- iMA : moyennes mobiles
- iRSI : Relative Strength Index
- iMACD
- iBands : bandes de Bollinger
- iATR : Average True Range
- iStochastic
- iADX
- iCCI
- iMomentum
- iIchimoku
- iSAR : Parabolic SAR
- iEnvelopes
- iWPR : Williams %R
- iAO : Awesome Oscillator
- iAC : Accelerator Oscillator
- iAlligator
- iFractals
- iOBV : On Balance Volume
- iVolumes
- iStdDev : écart-type
- iDeMarker
- iBearsPower et iBullsPower
- iForce
- iOsMA
- iRVI
- iAMA : moyenne mobile adaptative
- iDEMA et iTEMA
- iFrAMA
- iCustom : appeler un indicateur personnalisé
- Créer un indicateur personnalisé
- Buffers et styles de tracé
- OnCalculate et prev_calculated
- Indicateur multi-timeframe
- Objets graphiques (ObjectCreate)
