Contrats à terme continus dans MetaTrader 5

MetaTrader 5 — Indicateurs | 13 janvier 2022, 13:46

219

Introduction

Le trader ne peut pas créer ses propres graphiques dans MetaTrader 5 car il ne peut être construit qu'avec les symboles du broker. Le trader a besoin d'un produit synthétique - le contrat à terme continu. Le problème est que seul un broker peut effectuer des épissures de contrats et lui seul décide s'il connectera des contrats à terme sur le symbole donné.

Heureusement, l'historique des contrats à terme fermes est toujours disponible dans le terminal. Utilisez cet historique pour raccorder les contrats à terme dans le terminal.

Conventions:

Toutes les données, dessins et captures d'écran de l'article sont basés sur les contrats à terme sur indices boursiers ukrainiens réels.

Les sections de code remplacées ou ajoutées dans l'article seront marquées en couleur. Par exemple :

//+------------------------------------------------------------------+
//|                                               This is an example |
//|                                               of the edited code |
//+------------------------------------------------------------------+

Le premier problème : les dates se chevauchent

Les contrats à terme fermes sont négociés avec des dates qui se chevauchent.

Cela signifie que le contrat à terme est mis sur le marché alors qu'un autre a encore deux mois pour être clôturé.

Fig. 1. Les dates se chevauchent dans les contrats à terme fermes

La figure montre que 2013.09.16 est la date de début de la négociation des contrats à terme fermes UX-3.14, bien que les contrats UX-12.13 soient toujours ouverts.

Le deuxième problème : choisir la méthode d'épissage

Il existe deux méthodes d'épissage :

Le simple ajout - lorsque la date de circulation de l'instrument actuel a expiré et que l'instrument suivant est ouvert dans un autre bar. Pendant le simple ajout, les prix sur le graphique correspondront à leurs valeurs historiques, mais en même temps, il y aura toujours des écarts de prix aux endroits d'épissure, c'est-à-dire que le graphique ne sera pas lisse.

Fig. 2. Épissage. Ajout simple.

Fig. 2. Épissage. Ajout simple

ajout avec décalage : l'instrument actuel a 5-10 jours avant qu'il ne soit fermé et nous commençons à remplacer ces 5-10 barres par les prochaines barres de l'instrument. L'intervalle de 5 à 10 barres est appelé période de transition. Lors de l'addition avec décalage, les prix afficheront des valeurs erronées (elles ne correspondront pas à l'instrument actuel) mais par rapport à la méthode d'ajout simple, le graphique sera plus lisse.

Fig. 3. Épissage. Ajout avec décalage

Paramètres dans le terminal

Dans la fenêtre « Surveillance des marchés », les contrats à terme doivent être placés dans l'ordre décroissant :

Figure. 4. Observation du marché

Fig. 4. Surveillance des marchés

Supprimer un indicateur

L'indicateur par défaut doit être placé dans le dossier terminal_data_folder\MQL5\Indicators Créez le dossier Synthetics dans MyIndicators (que vous ouvrez dans \Indicators). Il vous permet d'économiser de l'espace dans le dossier \Indicators de la bibliothèque standard et facilite la synchronisation des indicateurs au lancement de Stockage MQL5. Le chemin final du dossier ressemble à ceci :terminal_data_folder\MQL5\Indicators\MyIndicators\Synthetics.

Dans le dossier Synthetics, créez un nouveau fichier :

Figure. 5. Nous créons le nouveau fichier de l'indicateur

Fig. 5. L'indicateur de création de nouveau fichier

Définissez le nouveau type de fichier - «Indicateur personnalisé»:

Figure. 6. Type du nouveau fichier - « indicateur personnalisé »

Fig. 6. Le nouveau type de fichier - «Indicateur personnalisé»

Appuyez sur «Suivant» et ouvrez la fenêtre «Propriétés générales de l'indicateur personnalisé». Entrez le nom de l'indicateur - «SYNT», ajoutez deux options. La première option «Nombre de contrats à terme pour l'épissage» détermine le nombre d'instruments à connecter. Notez que 2 est la valeur minimale possible du «Nombre de contrats à terme pour l'épissage». La deuxième option «Type de collage» détermine le type de raccordement dans l'indicateur par défaut - «ajout simple»:

Figure. 7. Paramètres de l'indicateur personnalisé

Fig. 7. Les paramètres de l'indicateur personnalisé

Attention à l'option « Type de collage » : le raccordement peut être « ajout simple » ou « ajout avec décalage » À ce stade, vous ne pouvez pas ajouter la liste de ces deux types d'épissage. C'est pourquoi laisser la valeur par défaut « ajout simple». Pendant l'écriture du code de l'indicateur "SYNT", activez l'option Plus tard pour voir la liste déroulante avec les types d'épissage.

Dans la fenêtre suivante, sélectionnez les gestionnaires d'événements indicateurs :

Figure. 8. Opérateur informatique des événements pour l'indicateur

Fig. 8. Les gestionnaires d'événements indicateurs

Notez que la fonction OnTimer() sera utilisée dans l'indicateur «SYNT». La fonctionnalité principale de l'indicateur est définie dans OnTimer() . L'indicateur peut être attaché à la fois au graphique des symboles avec la transaction terminée (ce symbole n'inclura pas les événements OnCalculate) et au graphique des symboles avec une transaction active.

Appuyez sur « Suivant » et dans les « Propriétés générales du programme d'indicateur personnalisé » cochez « Indicateur dans une fenêtre séparée » :

Figure. 9. Choisissez l'option «Indicateur dans une fenêtre séparée»

Fig. 9. Option «Indicateur dans une fenêtre séparée»

Appuyez sur le bouton «Terminé» et vous verrez le modèle d'indicateur «SYNT».

Organisation de la liste déroulante

Afin de voir la liste des types d'épissage comme liste déroulante, vous devez déclarer l'énumération ENUM_GLUING_TYPE dans les options de l'indicateur.

Déclarez l'énumération dans la zone globale au début du bloc des paramètres d'entrée :

#property indicator_separate_window
//+------------------------------------------------------------------+
//|  Splicing types enumeration                                      |
//+------------------------------------------------------------------+
enum ENUM_GLUING_TYPE
  {
   simple_addition,        // simple addition||simple addition
   addition_with_shift     // addition with shift||addition with shift
  };  
//--- input parameters || input parameters
input ENUM_GLUING_TYPE  gluing_type=simple_addition;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+

Vous pouvez maintenant vérifier comment la liste déroulante est affichée.

Vous devez compiler le fichier indicateur (F7). Maintenant, après avoir attaché l'indicateur, vous pouvez voir dans les options que la liste déroulante se lance :

Figure. 10. Nous avons maintenant une liste déroulante dans les paramètres

Fig. 10. Maintenant vous avez la
liste déroulante dans les paramètres

Ajoutez la description de l'indicateur qui s'affichera dans l'onglet «Général» lorsqu'il sera attaché au graphique pour la première fois ou lorsque ses propriétés seront modifiées :

#property version   "1.00"
//+------------------------------------------------------------------+
//| version   "1.00": The timer history swapping                     |
//+------------------------------------------------------------------+
#property description "Indicator for several futures splicing."
#property description "Is drawn in the latest futures window"
#property description "Uses N first symbols for drawing"
#property description "which were taken from the \"Market review\"."

#property indicator_separate_window

La méthode de construction de l'indicateur - DRAW_COLOR_CANDLES - - chandelles colorées.

Vous avez besoin de 4 tampons indicateurs et d'un tampon pour le magasin d'index de couleur. Le style de la ligne, indicateur - STYLE_SOLID - ligne continue. Tout afficher dans le code indicateur :

#property description "taken from the \"Market review\"."

//--- indicator settings || indicator settings
#property indicator_separate_window
#property indicator_buffers 5 
#property indicator_plots   1
//--- plot Bars || bars plotting
#property indicator_label1    "SYNT"
#property indicator_type1     DRAW_COLOR_CANDLES
#property indicator_style1    STYLE_SOLID
#property indicator_width1    1
//+------------------------------------------------------------------+
//|  enumeration of splicing methods                                 |
//+------------------------------------------------------------------+

Entrez le paramètre d'entrée «number_futures_gluing» - nombre d'instruments requis pour la construction. La valeur par défaut «number_futures_gluing» est égale à 2 :

//--- input parameters || input parameters
input int               numder_futures_gluing=2;
input ENUM_GLUING_TYPE  gluing_type=simple_addition;

Déclarez 4 tampons indicateurs, 1 tampon pour le stockage de l'index de couleur et le tableau auxiliaire LoadHistory[]:

#property indicator_style1    STYLE_SOLID
#property indicator_width1    1
//--- indicator buffers || indicator buffers
double            OpenBuffer[];
double            HighBuffer[];
double            LowBuffer[];
double            CloseBuffer[];
double            ColorCandlesColors[];
double            LoadHistory[];
//+------------------------------------------------------------------+
//|  enumeration of splicing methods                                 |
//+------------------------------------------------------------------+

Attachez des tampons d'indicateurs aux tableaux dynamiques à une dimension, définissez l'indexation des tampons comme dans les séries temporelles :

//--- indicator buffers mapping
//--- indicator buffers mapping
   SetIndexBuffer(0,OpenBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,HighBuffer,INDICATOR_DATA);
   SetIndexBuffer(2,LowBuffer,INDICATOR_DATA);
   SetIndexBuffer(3,CloseBuffer,INDICATOR_DATA);
   SetIndexBuffer(4,ColorCandlesColors,INDICATOR_COLOR_INDEX);
   SetIndexBuffer(5,LoadHistory,INDICATOR_CALCULATIONS);
//--- set buffer indexing as timeseries
//--- set buffer indexing as in timeseries
   ArraySetAsSeries(OpenBuffer,true);
   ArraySetAsSeries(HighBuffer,true);
   ArraySetAsSeries(LowBuffer,true);
   ArraySetAsSeries(CloseBuffer,true);
   ArraySetAsSeries(ColorCandlesColors,true);
//---
   return(INIT_SUCCEEDED);

Pour afficher le nom de la série d'indicateurs («Ouvrir», «Haut», «Bas» et «Fermer») dans la «Fenêtre de données», vous avez besoin de la variable s_symbol :

input int               numder_futures_gluing=2;
input ENUM_GLUING_TYPE  gluing_type=simple_addition;
//--- symbol name
string s_symbol;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+

Pour activer l'indicateur, vous avez besoin de la variable shft_array et de deux indicateurs good_history et indicator_rendered

input ENUM_GLUING_TYPE  gluing_type=simple_addition;
//--- symbol name
string   s_symbol;
int      shift_array=0;
bool     good_history=false;        //history is not prepared||history not prepared
bool     indicator_rendered=false;  // indicator is not drawn
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+

Configurez ensuite l'indicateur et connectez l'index de couleur du tampon à la couleur choisie :

   ArraySetAsSeries(CloseBuffer,true);
   ArraySetAsSeries(ColorCandlesColors,true);
//--- set accuracy || accuracy of the indicator values 
   IndicatorSetInteger(INDICATOR_DIGITS,0);
//--- set drawing line empty value || empty value of the drawing line 
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
//--- set labels for the line || displayed name in the DataWindow
   PlotIndexSetString(0,PLOT_LABEL,s_symbol+" Open;"+s_symbol+" High;"+s_symbol+" Low;"+s_symbol+" Close");
   IndicatorSetString(INDICATOR_SHORTNAME,"SYNT");
//--- set number of colors in color buffer || number of colors in the buffer
   PlotIndexSetInteger(0,PLOT_COLOR_INDEXES,9);
//--- set line color || set the line color
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,clrBlue);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,clrOrange);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,2,clrRed);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,3,clrGreen);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,4,clrPink);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,5,clrIndigo);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,6,clrPaleVioletRed);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,7,clrDarkViolet);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,8,clrDimGray);
//---
   return(INIT_SUCCEEDED);

Ajoutez l'initialisation de la minuterie avec un intervalle de 3 secondes et le générateur de nombres aléatoires dans la fonction OnInit() :

   PlotIndexSetInteger(0,PLOT_LINE_COLOR,7,clrDarkViolet);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,8,clrDimGray);
//---
   EventSetTimer(3);
//--- random number generator initializor
   MathSrand(GetTickCount());
//---
   return(INIT_SUCCEEDED);

Il faut au moins deux symboles pour traiter l'épissage.

Vérifiez le nombre d'instruments pour l'épissage dans la fonction OnCalculate() :

                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//--- checking the number of instruments || checking the number of instruments
   if(numder_futures_gluing<=1)
     {
      //--- create the message line
      string comm=StringFormat("For the indicator choose not less than %d symbols",numder_futures_gluing);
      //--- display the message in comment in the chart main window
      Comment(comm);
      return(0);
     }
//--- return value of prev_calculated for next call
   return(rates_total);

Après avoir vérifié le nombre de symboles pour l'épissage, vous vérifiez si l'indicateur a déjà été dessiné. Si l'indicateur est dessiné, alors vous pouvez quitter le OnCalculate() :

      Comment(comm);
      return(0);
     }
   if(indicator_rendered==true) return(rates_total);
//--- return value of prev_calculated for next call
   return(rates_total);

Comme l'indicateur «SYNT» est principalement utilisé pour analyser la tendance de développement des barres journalières, je considère qu'il n'est pas nécessaire de procéder à des recalculs à chaque tick. Il n'y aura pas de calculs de l'indicateur «SYNT» sur chaque tick.

De plus, vous ne devez calculer l'indicateur que dans les cas suivants :

si l'indicateur a été lancé la première fois ;
si l'historique a été modifié (par exemple, il y a eu des ajouts).

   if(indicator_rendered==true) return(rates_total);
//--- if calculations were started the first time
//--- or if we need to calculate the indicator for two or more bars (changes in history)
//--- remember, that the "0" bar - is the left-most
   if(prev_calculated==0 || rates_total>prev_calculated+1)
     {
     }
//--- return value of prev_calculated for next call
   return(rates_total);

Initialisation forcée des tampons indicateurs

Les tampons indicateurs «SYNT» sont des tableaux dynamiques connectés.

Lors du premier lancement de l'indicateur, les tampons sont initialisés de force. Procédez à l'initialisation dans OnCalculate(). Pourquoi avez-vous besoin de l'effectuer dans OnCalculate(), et pas dans OnInit? L'explication est dans la figure ci-dessous :

Fig. 11. L'initialisation du tableau dans OnCalculate()

Comme vous pouvez le voir sur la Fig.11, l'événement OnCalculate() se produira dans tous les cas, alors que OnInit() est activé lorsque vous lancez la mise à jour du graphique via la commande «mise à jour». Par conséquent, l'initialisation des tableaux sera effectuée dans OnCalculate() :

//--- remember, that the "0" bar - is the left-most
   if(prev_calculated==0 || rates_total>prev_calculated+1)
     {
      //--- arrays initialization
      ArrayInitialize(OpenBuffer,0);
      ArrayInitialize(HighBuffer,0);
      ArrayInitialize(LowBuffer,0);
      ArrayInitialize(CloseBuffer,0);
     }
//--- return value of prev_calculated for next call
   return(rates_total);

La fonction ArrayInitialize() initialise le tampon indicateur. Dans ce cas, l'initialisation affiche des zéros.

Si vous essayez d'initialiser l'indicateur de tampon par le EMPTY_VALUE , vous ne pourrez pas épisser les indicateurs sur le «SYNT».

Algorithme d'ajout simple

Figure. 12. Algorithme d'ajout simple

Fig. 12. Algorithme d'ajout simple

Les dates sur l'image sont les dates de début et de fin de la circulation à terme UX-9.13, UX-12.13 et UX-3.14 Ces données sont présentées dans le tableau :

Symbole	La circulation commence	Circulations finit
UX-9.13	2013.03.15	2013.09.16
UX-12.13	2013.06.17	2013.12.16
UX-3.14	2013.09.16	2014.03.17

Dans la Fig. 10 2013.12.25 date - est une vraie date calendaire. Le symbole UX-3.14 est toujours valide.

La méthode d'épissage « ajout simple » sera implémentée dans la fonction SimpleAddition :

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
//---
  }
//+------------------------------------------------------------------+
//| Simple addition                                                  |
//| Simple addition. Add in the indicator array                      |
//| sibmUP symbol                                                    |
//+------------------------------------------------------------------+
bool SimpleAddition(string simbUP,string simbDOWN,ENUM_TIMEFRAMES period,int Color)
  {
  }
//+------------------------------------------------------------------+

simbUP est le contrat à terme vers le haut, simbDOWN est le contrat à terme fermes vers le bas, les deux sont situés dans la fenêtre « Revue du marché ». Couleur - couleur utilisée pour dessiner les futures.

Le code complet de la fonction SimpleAddition() est donné ci-dessous :

//+------------------------------------------------------------------+
//| Simple addition                                                  |
//| Simple addition. Add in the indicator array                      |
//| sibmUP symbol                                                    |
//+------------------------------------------------------------------+
bool SimpleAddition(string simbUP,string simbDOWN,ENUM_TIMEFRAMES period,int Color)//////
  {
   datetime expiration_time_UP;     // simbUP symbol expiration date
   datetime expiration_time_DOWN;   // simbDOWN expiration date

   expiration_time_UP=int(SymbolInfoInteger(simbUP,SYMBOL_EXPIRATION_TIME));
   if(expiration_time_UP>TimeLocal())
     {
      expiration_time_UP=TimeLocal();
     }
   if(simbDOWN!="")
     {
      expiration_time_DOWN=int(SymbolInfoInteger(simbDOWN,SYMBOL_EXPIRATION_TIME));
     }
   else
     {
      expiration_time_DOWN=int(SymbolInfoInteger(simbUP,SYMBOL_START_TIME));
     }
//--- Open, High, Low and Close prices will be copied in the rates[] array 
   MqlRates rates[];
   ArraySetAsSeries(rates,true);
   int copied=0;           //--- copied number
   copied=CopyRates(simbUP,period,expiration_time_DOWN,expiration_time_UP,rates);
   if(copied>0)
     {
      for(int j=shift_array;j<shift_array+copied;j++)
        {
         //--- write prices in buffers
         OpenBuffer[j]=rates[j-shift_array].open;
         HighBuffer[j]=rates[j-shift_array].high;
         LowBuffer[j]=rates[j-shift_array].low;
         CloseBuffer[j]=rates[j-shift_array].close;
         ColorCandlesColors[j]=Color;
        }
      shift_array=shift_array+copied;
      indicator_rendered=true;
      ChartRedraw();
     }
   else
     {
      Print("Unable to get the symbol history data",simbUP);
      indicator_rendered=false;
      return(false);
     }
//---  Simple addition end
   return(true);
  }
//+------------------------------------------------------------------+

Addition avec algorithme de décalage

Figure. 13. Algorithme de collage - ajouté avec décalage

Fig. 13. Ajout avec algorithme d'épissage de décalage

L'épissage dans cet algorithme, par rapport à la simple addition, commence 10 jours avant la fermeture du symbole. La méthode d'épissage «Ajout avec décalage» est traitée dans la fonctionAdditionWithShift() :

//--- Simple addition end
   return(true);
  }
//+------------------------------------------------------------------+
//| Addition With Shift                                              |
//| Addition with Shift. Add in the indicator array only             |
//| sibmUP symbol                                                    |
//+------------------------------------------------------------------+
bool AdditionWithShift(string simbUP,string simbDOWN,ENUM_TIMEFRAMES period,int Color)
  {
//--- 
   return(true);
  }
//+------------------------------------------------------------------+

La différence entre les fonctions AdditionWithShift() et SimpleAddition() est sur deux lignes - vous soustrayez 10 jours aux dates :

   .
   .
   .
   expiration_time_UP=int(SymbolInfoInteger(simbUP,SYMBOL_EXPIRATION_TIME))-86400*10;
   .
   .
   .
   expiration_time_DOWN=int(SymbolInfoInteger(simbDOWN,SYMBOL_EXPIRATION_TIME))-86400*10;
   .
   .
   .

En raison d'une petite différence dans les codes, je ne montrerai pas le code complet de la fonction AdditionWithShift(), vous pouvez trouver le code dans le fichier indicateur de l'article.

Malgré une si petite différence entre les fonctions AdditionWithShift() et SimpleAddition(), il est préférable de ne pas les assembler pour en faire une fonction universelle (en cas de modifications supplémentaires de l'algorithme ou, par exemple, de lancements de tests).

Préchargement de l'historique des symboles

La fonction CheckLoadHistory() copie tout l'historique des symboles dans le tampon auxiliaire tmp_rates.

Si le processus de copie réussit, la vraie valeur est attribuée à l'indicateur good_history, ce qui signifie que vous pouvez commencer à dessiner l'indicateur :

//--- Addition With Shift end
   return(true);
  }
//+------------------------------------------------------------------+
//| Request to receive all history from a trade server               |
//| Request to recieve all history from a trade server               |
//+------------------------------------------------------------------+
bool CheckLoadHistory(string symbol,ENUM_TIMEFRAMES period)
  {
   MqlRates tmp_rates[];      // the Open, High, Low and Close prices will be copied in the rates[]array 
   datetime start_time;       // start time of the instrument trades
   datetime expiration_time;  // expiration time of the instrument trade
   start_time=int(SymbolInfoInteger(symbol,SYMBOL_START_TIME));
   expiration_time=int(SymbolInfoInteger(symbol,SYMBOL_EXPIRATION_TIME));
   if(CopyRates(symbol,period,start_time,expiration_time,tmp_rates)>0)
     {
      good_history=true;
     }
   else
     {
      good_history=false;
     }
//--- 
   return(true);
  }
//+------------------------------------------------------------------+

Vous pouvez copier tout l'historique des symboles car la durée de vie des contrats à termes est très courte et toute copie de l'historique ne prendra pas beaucoup de place.

OnTimer - la fonction principale de l'indicateur

Vous avez maintenant le code pour deux méthodes d'épissage et le code pour le chargement de l'historique, vous pouvez donc modifier la fonction OnTimer():

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
   if(indicator_rendered==true) return;
   if(good_history==true)
     {
      int t=0;       // color || color
      int number;
      switch(gluing_type)
        {
         case simple_addition:
            for(int n=0;n<numder_futures_gluing;n++)
              {
               //--- get the random number
               number=MathRand();
               //--- get the color index as the modulo
               t=number%(PlotIndexGetInteger(0,PLOT_COLOR_INDEXES)-1);
               SimpleAddition(SymbolName(n,true),SymbolName(n+1,true),PERIOD_D1,t);
              }
            break;
         case addition_with_shift:
            for(int n=0;n<numder_futures_gluing;n++)
              {
               //--- get random number
               number=MathRand();
               //--- get the color index as the modulo
               t=number%(PlotIndexGetInteger(0,PLOT_COLOR_INDEXES)-1);
               AdditionWithShift(SymbolName(n,true),SymbolName(n+1,true),PERIOD_D1,t);
              }
            break;
        }
     }
   else
     {
      for(int n=0;n<numder_futures_gluing;n++)
        {
         CheckLoadHistory(SymbolName(n,true),PERIOD_D1);
        }
     }
  }
//+------------------------------------------------------------------+

L'indicateur est construit. Vous pouvez le compiler et le joindre au graphique. Il est préférable de choisir le symbole de trade fermé et de définir la période H1.

Sortie initiale de l'indicateur «SYNT»

Après avoir joint au graphique les deux modèles d'indicateurs «SYNT» des différentes méthodes d'épissage, vous pouvez comparer ces méthodes :

Fig. 14. Deux méthodes de comparaison d'épissage à termes

La possibilité de raccorder des indicateurs (standard et personnalisés)

Les indicateurs personnalisés peuvent être épissés avec le premier appel OnCalculate et l'indicateur «SYNT» :

int OnCalculate (const int rates_total,      // size of the array price[]
                 const int prev_calculated,  // calculated bars during the previous call
                 const int begin,            // tangible data starting point
                 const double& price[]       // calculation array
   );

Dans la fenêtre «Navigateur» ouvrez la liste «Indicateurs personnalisés». Ouvrez ensuite la liste «Exemples», choisissez l'indicateur et placez-le dans «SYNT». Dans l'onglet «Paramètres», choisissez «Données d'indicateur précédentes» dans la liste déroulante.

Voici la liste des indicateurs que vous pouvez coller sur l'indicateur «SYNT», ils se lancent sur le «SYNT» sans erreur :

L'indicateur «SYNT» qui a épissé trois contrats à termes avec l'indicateur Moyenne mobile personnalisé ci-joint :

Figure. 15. Exemple de collage de trois symboles

Fig. 15. Un exemple de trois symboles épissés

Conclusion

Il est plus facile d'analyser le comportement d'anciens symboles de graphique ouverts au cours de la journée. Bien que le nombre d'indicateurs techniques soit restreint, cette méthode permet de retracer le comportement des prix sur les futures en continu.

Traduit du russe par MetaQuotes Ltd.
Article original : https://www.mql5.com/ru/articles/802

Fichiers joints |

Télécharger ZIP

synt.mq5 (24.66 KB)

Avertissement: Tous les droits sur ces documents sont réservés par MetaQuotes Ltd. La copie ou la réimpression de ces documents, en tout ou en partie, est interdite.

Autres articles par cet auteur

Aller à la discussion

Création de filtres numériques à temps

L'article décrit l'une des approches permettant de déterminer un signal utile (tendance) dans les données de flux. De petits tests de filtrage (lissage) appliqués aux cotations boursières démontrent le potentiel de création de filtres numériques sans retard (indicateurs) qui ne sont pas redessinés sur les dernières barres.

Travailler avec le modem GSM d'un Expert Advisors de MQL5

Il existe actuellement de nombreux moyens pour un bon suivi à distance d'un compte de trading : terminaux mobiles, notifications push, fonctionnement avec ICQ. Mais tout cela nécessite une connexion Internet. Cet article décrit le processus de création d'un Expert Advisor qui vous permettra de rester en contact avec votre terminal de trading même lorsque l'Internet mobile n'est pas disponible, par le biais d'appels et de SMS.

Regardez la vidéo tutoriel Service de signaux MetaTrader

En seulement 15 minutes, ce didacticiel vidéo explique ce qu'est le service de signaux MetaTrader et montre en détail comment s'abonner aux signaux de trading et comment devenir un fournisseur de signaux dans notre service. En regardant ce tutoriel, vous pourrez vous abonner à n'importe quel signal de trading, ou publier et promouvoir vos propres signaux dans notre service.

Indicateur pour la cartographie Renko

L'article décrit un exemple de graphique Renko et sa mise en œuvre dans MQL5 en tant qu'indicateur. Des modifications de cet indicateur le distinguent d'un graphique classique. Il peut être construit à la fois dans la fenêtre de l'indicateur et sur le graphique principal. De plus, il y a l'indicateur ZigZag. Vous pouvez y trouver quelques exemples de mise en œuvre du graphique.