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

MQL5 · Indicateurs

iRVI en MQL5 : le Relative Vigor Index, ses deux buffers et ses croisements

iRVI() fournit la ligne RVI et sa ligne de signal dans deux buffers. Calcul, lecture avec MAIN_LINE et SIGNAL_LINE, croisements fiables et classe réutilisable.

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

iRVI(symbol, period, ma_period) crée un handle vers le Relative Vigor Index de MetaTrader 5. Contrairement à la plupart des oscillateurs à un seul buffer, il en possède deux : la ligne RVI (buffer 0, constante MAIN_LINE) et sa ligne de signal (buffer 1, constante SIGNAL_LINE). Le signal classique est le croisement des deux lignes. Cette page montre comment lire proprement deux buffers d’un même handle, comment détecter un croisement sans faux positifs, et comment encapsuler le tout dans une petite classe réutilisable.

Signature et buffers

int iRVI(
   string           symbol,     // symbole, NULL = courant
   ENUM_TIMEFRAMES  period,     // unité de temps, 0 = courante
   int              ma_period   // période de moyenne
   );
BufferConstanteContenu
0MAIN_LINELigne principale du RVI
1SIGNAL_LINELigne de signal

La fonction renvoie INVALID_HANDLE en cas d’échec, et le handle se libère avec IndicatorRelease(). Utiliser les constantes MAIN_LINE et SIGNAL_LINE plutôt que les chiffres 0 et 1 rend le code plus lisible, et évite d’inverser les deux lignes en relisant un programme des mois plus tard.

L’idée du Relative Vigor Index

L’aide de MetaTrader 5 part d’une observation : en marché haussier, la clôture se situe le plus souvent au-dessus de l’ouverture, et en marché baissier, en dessous. La « vigueur » d’un mouvement se mesure donc à la position de la clôture par rapport à l’ouverture, rapportée à l’amplitude de la bougie :

RVI = (CLOSE - OPEN) / (HIGH - LOW)

Pour réduire le bruit, le terminal applique une moyenne pondérée symétrique sur quatre bougies au numérateur (CLOSE - OPEN) comme au dénominateur (HIGH - LOW), avec des poids 1, 2, 2, 1. La ligne de signal est à son tour une moyenne pondérée symétrique de la ligne RVI sur quatre valeurs : (RVI + 2×RVI[-1] + 2×RVI[-2] + RVI[-3]) / 6. L’aide indique une période de 10 comme réglage de référence.

Deux conséquences pratiques. D’abord, le RVI est une mesure normalisée par l’amplitude : ses valeurs restent faibles, généralement comprises entre -1 et 1, quel que soit l’instrument. Ensuite, la ligne de signal a un retard fixe et court : les croisements sont fréquents. C’est un oscillateur réactif, qui demande presque toujours un filtre.

Détecter un croisement correctement

Un croisement se définit sur deux bougies closes : la ligne principale était sous la ligne de signal sur la bougie 2, et au-dessus (ou à égalité) sur la bougie 1. Trois erreurs reviennent souvent :

  1. comparer la bougie en cours (index 0) à la précédente : la valeur de la bougie 0 change à chaque tick, et un croisement peut apparaître puis disparaître avant la clôture ;
  2. lire une seule bougie et tester main > signal : ce n’est pas un croisement mais un état, qui reste vrai pendant des dizaines de bougies ;
  3. copier les deux buffers avec des positions de départ différentes, ce qui décale les lignes l’une par rapport à l’autre.

La classe ci-dessous traite ces trois points.

Exemple complet : une classe de détection de croisement

//+------------------------------------------------------------------+
//| RviCross.mq5 - croisements RVI / signal encapsulés dans une classe|
//+------------------------------------------------------------------+
input int    InpPeriod = 10;    // période du RVI
input double InpMinGap = 0.02;  // écart minimal après croisement

class CRviCross
  {
private:
   int               m_handle;
   double            m_main[];
   double            m_signal[];
public:
                     CRviCross(void) : m_handle(INVALID_HANDLE) {}
                    ~CRviCross(void) { if(m_handle != INVALID_HANDLE) IndicatorRelease(m_handle); }

   bool              Init(const string symbol, ENUM_TIMEFRAMES tf, int period)
     {
      m_handle = iRVI(symbol, tf, period);
      ArraySetAsSeries(m_main, true);
      ArraySetAsSeries(m_signal, true);
      return(m_handle != INVALID_HANDLE);
     }

   //--- lit les bougies closes 1 et 2 des deux lignes, mêmes positions
   bool              Refresh(void)
     {
      if(CopyBuffer(m_handle, MAIN_LINE,   1, 2, m_main)   != 2) return(false);
      if(CopyBuffer(m_handle, SIGNAL_LINE, 1, 2, m_signal) != 2) return(false);
      return(true);
     }

   //--- +1 croisement haussier, -1 baissier, 0 aucun
   int               Cross(double minGap)
     {
      double prev = m_main[1] - m_signal[1];   // bougie 2
      double last = m_main[0] - m_signal[0];   // bougie 1
      if(prev < 0.0 && last >=  minGap) return(+1);
      if(prev > 0.0 && last <= -minGap) return(-1);
      return(0);
     }

   double            Main(void)   const { return(m_main[0]); }
  };

CRviCross rvi;

int OnInit()
  {
   if(!rvi.Init(_Symbol, PERIOD_CURRENT, InpPeriod))
     {
      PrintFormat("iRVI : échec, erreur %d", GetLastError());
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }

void OnTick()
  {
   static datetime lastBar = 0;
   datetime bar = iTime(_Symbol, PERIOD_CURRENT, 0);
   if(bar == lastBar) return;
   if(!rvi.Refresh()) return;          // données pas prêtes : on réessaie
   lastBar = bar;

   int c = rvi.Cross(InpMinGap);
   if(c != 0)
      PrintFormat("%s : croisement RVI %s (RVI = %.3f)", _Symbol,
                  c > 0 ? "haussier" : "baissier", rvi.Main());
  }

La libération du handle se fait dans le destructeur de la classe : l’objet global rvi est détruit à la fin du programme, ce qui appelle IndicatorRelease() sans qu’il soit nécessaire d’écrire un OnDeinit(). Cette approche devient intéressante dès qu’un robot manipule plusieurs indicateurs, car chaque objet gère lui-même son handle. Si les classes MQL5 ne vous sont pas familières, la page Programmation orientée objet : classes en présente les bases.

Réutiliser la classe sur deux unités de temps

Comme la méthode Init() reçoit le symbole et l’unité de temps, vous pouvez déclarer deux objets : CRviCross rviH1, rviM15;, initialisés respectivement avec PERIOD_H1 et PERIOD_M15. Le robot peut alors exiger que la ligne principale du RVI H1 soit au-dessus de sa ligne de signal (un état, lu avec une méthode supplémentaire) avant d’accepter un croisement haussier en M15. Attention à la cadence : la méthode Refresh() de l’objet H1 relit les deux dernières bougies H1 closes, qui ne changent qu’une fois par heure ; il est inutile de déclencher une évaluation supplémentaire à chaque bougie H1, la lecture à chaque bougie M15 suffit. Le sujet est développé sur la page Indicateur multi-timeframe.

Le paramètre d’écart minimal

InpMinGap impose qu’après le croisement, l’écart entre les deux lignes atteigne une valeur minimale. Sans ce paramètre, deux lignes qui ondulent l’une autour de l’autre produisent un croisement à chaque bougie. Comme le RVI est normalisé par l’amplitude des bougies, un même écart garde à peu près le même sens d’un instrument à l’autre, ce qui n’est pas le cas des oscillateurs exprimés en prix comme l’OsMA. Gardez néanmoins une valeur prudente et vérifiez-la sur le graphique : une valeur trop grande retarde le signal jusqu’à le rendre inutile.

Filtres et contexte de marché

Le RVI répond à une seule question : les bougies récentes clôturent-elles plutôt près de leur plus haut ou de leur plus bas ? Il ne dit rien de la tendance de fond. Trois filtres complémentaires sont courants :

  • la position du croisement : un croisement haussier sous zéro (après une phase de clôtures faibles) est souvent plus significatif qu’un croisement au-dessus de zéro ;
  • une tendance supérieure : n’accepter que les croisements dans le sens d’une moyenne mobile longue ou d’une unité de temps supérieure ;
  • la volatilité : écarter les périodes où l’amplitude des bougies est très faible, car le rapport (CLOSE - OPEN) / (HIGH - LOW) devient alors instable.

Pour coder ce dernier filtre, voyez Filtres horaires, de spread et de volatilité.

Pièges spécifiques au RVI

  • Les bougies doji. Quand HIGH - LOW est très petit, la moindre variation de clôture fait bouger fortement le rapport. La moyenne sur quatre bougies limite l’effet, sans le supprimer.
  • Les gaps. Le RVI compare la clôture à l’ouverture de la même bougie : un gap entre deux bougies n’est pas pris en compte. Après une ouverture en gap, le RVI peut indiquer une faible vigueur alors que le prix a fortement bougé.
  • Les unités de temps très courtes. En M1, beaucoup de bougies ont une ouverture et une clôture identiques, et l’oscillateur devient très plat.

Pour comparer avec un oscillateur de clôture classique, voyez iStochastic, qui possède lui aussi une ligne principale et une ligne de signal. L’ensemble des indicateurs intégrés est présenté sur la page Indicateurs en MQL5.

Les croisements d’oscillateurs sont des signaux fréquents et souvent contradictoires. Évaluez votre règle sur un historique suffisamment long, mesurez son espérance après frais, et validez-la en démo avant tout usage sur un compte réel.

FAQ

Combien de buffers possède iRVI ?

Deux : la ligne principale (buffer 0, MAIN_LINE) et la ligne de signal (buffer 1, SIGNAL_LINE). Chacun se lit avec un appel distinct à CopyBuffer() sur le même handle.

Quelle période utiliser pour le RVI ?

L’aide de MetaTrader 5 cite une période de 10 comme réglage de référence. Comme pour tout paramètre, vérifiez sa stabilité sur votre instrument plutôt que de chercher une valeur optimale précise.

Pourquoi mes croisements RVI apparaissent-ils puis disparaissent-ils ?

Parce que vous lisez la bougie en cours, dont la valeur change à chaque tick. Basez la détection sur les bougies closes 1 et 2.

Le RVI est-il borné ?

Il n’a pas de bornes fixes déclarées, mais comme il rapporte l’écart clôture-ouverture à l’amplitude des bougies, ses valeurs restent faibles et comparables d’un instrument à l’autre.

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.