Dessiner les Émissions de l'Indicateur en MQL5

MetaTrader 5 — Exemples | 15 novembre 2021, 14:31

185

Sergey Pavlov

Introduction

Certes, de nombreux traders et développeurs de stratégies de trading s'intéressent à ces questions :

Comment les forts mouvements du marché émergent-t-ils ?
Comment déterminer la bonne direction des changements à venir ?
Comment ouvrir une position de trade rentable?
Comment clôturer une position avec un bénéfice maximal ?

Trouver les réponses à ces questions m'a conduit à l’élaboration d'une nouvelle approche de l'étude de marché : la construction et l'analyse d'indicateurs d'émissions. Pour plus de clarté, jetez un œil aux figures suivantes :

Fig. 1 Indicateur d'émission DCMV.

Fig. 1 Indicateur d'émission DCMV

Fig. 2. Émission de l'indicateur, basée sur les enveloppes iMA.

Fig. 2. Emission d’indicateur, basée sur des enveloppes iMA.

Il indique l'émission de différents indicateurs, mais le principe de leur construction est le même. De plus en plus de points de couleur et de forme différentes apparaissent après chaque coche. Ils forment de nombreux amas sous forme de nébuleuses, de nuages, de pistes, de lignes, d'arcs, etc. Ces formes peuvent contribuer à détecter les ressorts et les forces invisibles qui affectent le mouvement des prix du marché. La recherche et l'analyse de ces émissions sont quelque chose comme la chiromancie.

L'émission et ses propriétés

L'émission est un ensemble de points, situés aux points d'intersection de lignes spécifiques de l'indicateur.

Les propriétés des émissions ne sont pas encore claires, elles attendent toujours les chercheurs. Voici une liste des propriétés connues :

les points de même type ont tendance à se regrouper ;
l'émission a une direction - du présent vers le futur ou vers le passé;
les groupes sont importants - les groupes denses peuvent attirer ou, au contraire, peuvent repousser le prix.

Calcul de l'émission de l'indicateur

Examinons les principes fondamentaux du calcul des émissions à l'aide d'un Exemple: Prenons deux indicateurs - iBands et iMA - et trouvons l'intersection de leurs lignes. Nous les utiliserons pour dessiner les points d'émission. Pour cela, nous aurons besoin d'objets graphiques. L'algorithme est implémenté dans les Expert Advisors, mais cela peut être fait dans les indicateurs.

Les premiers indicateurs sont présentés dans la Fig. 3. :

Fig. 3. Les indicateurs iBands (vert) et iMA (rouge).

Nous avons besoin d'un Expert Advisor pour créer des points d'émission. Il est préférable d'utiliser l'assistant MQL5 pour créer un modèle Expert Advisor.

Fig. 4. Création d'un modèle Expert Advisor à l'aide de l'assistant MQL5.

//+------------------------------------------------------------------+
//|                                      Emission of Bands && MA.mq5 |
//|                                                 Copyright DC2008 |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "DC2008"
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   
  }
//+------------------------------------------------------------------+

Tout d'abord, nous avons besoin de quelques tracés auxiliaires. Nous devons poursuivre les lignes indicatrices à l'aide de rayons (Fig. 5.). Il permettra de contrôler la justesse du calcul et de la visualisation des points d'émission. Plus tard, nous supprimerons ces lignes du graphique.

Fig. 5. Tracés auxiliaires. Continuation des lignes de l'indicateur à l'aide de rayons.

Fig. 5. Tracés Auxiliaires Poursuite des lignes de l'indicateur à l'aide de rayons.

Ajoutons donc les objets graphiques (lignes horizontales et de tendance) au code de notre Expert Advisor.

input bool     H_line=true;   // flag to enable drawing of the horizontal lines
input bool     I_line=true;   // flag to enable drawing of the indicator's lines
//---
string         name;
//---- indicator buffers
double      MA[];    // array for iMA indicator 
double      BBH[];   // array for iBands indicator  - UPPER_BAND 
double      BBL[];   // array for iBands indicator - LOWER_BAND
double      BBM[];   // array for iBands indicator - BASE_LINE
datetime    T[];     // array for time coordinates
//---- handles for indicators
int         MAHandle;   // iMA indicator handle
int         BBHandle;   // iBands indicator handle
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   MAHandle=iMA(Symbol(),0,21,0,MODE_EMA,PRICE_CLOSE);
   BBHandle=iBands(Symbol(),0,144,0,2,PRICE_CLOSE);
//---
   if(H_line)     // Horizontal lines of iBands indicator
      {
         //--- iBands - UPPER_BAND
         name="Hi";
         ObjectCreate(0,name,OBJ_HLINE,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,Red);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_DOT);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
         //--- iBands - LOWER_BAND
         name="Lo";
         ObjectCreate(0,name,OBJ_HLINE,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,Blue);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_DOT);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
         //--- iBands - BASE_LINE
         name="MIDI";
         ObjectCreate(0,name,OBJ_HLINE,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,DarkOrange);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_DOT);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
      }
//---
   if(I_line)     // Indicator lines
      {
         //--- iMA
         name="MA";
         ObjectCreate(0,name,OBJ_TREND,0,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,Red);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_SOLID);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,2);
         ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_LEFT,1);
         //--- iBands - UPPER_BAND
         name="BH";
         ObjectCreate(0,name,OBJ_TREND,0,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,MediumSeaGreen);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_SOLID);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_LEFT,1);
         //--- iBands - LOWER_BAND
         name="BL";
         ObjectCreate(0,name,OBJ_TREND,0,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,MediumSeaGreen);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_SOLID);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_LEFT,1);
         //--- iBands - BASE_LINE
         name="BM";
         ObjectCreate(0,name,OBJ_TREND,0,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,MediumSeaGreen);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_SOLID);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_LEFT,1);
      }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   //--- filling the arrays with current values
   CopyBuffer(MAHandle,0,0,2,MA);
   ArraySetAsSeries(MA,true);  
   CopyBuffer(BBHandle,0,0,2,BBM);
   ArraySetAsSeries(BBM,true);  
   CopyBuffer(BBHandle,1,0,2,BBH);
   ArraySetAsSeries(BBH,true);  
   CopyBuffer(BBHandle,2,0,2,BBL);
   ArraySetAsSeries(BBL,true);
   CopyTime(Symbol(),0,0,10,T);
   ArraySetAsSeries(T,true);
     
   //--- Horizontal lines of iBands indicator (correction)
   if(H_line)
      {
      name="Hi";
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBH[0]);
      name="Lo";
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBL[0]);
      name="MIDI";
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBM[0]);
      }
   //--- Indicator's lines (correction)
   if(I_line)
      {
      name="MA";  //--- iMA
      ObjectSetInteger(0,name,OBJPROP_TIME,T[1]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,MA[1]);
      ObjectSetInteger(0,name,OBJPROP_TIME,1,T[0]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,1,MA[0]);
      name="BH";  //--- iBands - UPPER_BAND
      ObjectSetInteger(0,name,OBJPROP_TIME,T[1]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBH[1]);
      ObjectSetInteger(0,name,OBJPROP_TIME,1,T[0]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,1,BBH[0]);
      name="BL";  //--- iBands - LOWER_BAND
      ObjectSetInteger(0,name,OBJPROP_TIME,T[1]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBL[1]);
      ObjectSetInteger(0,name,OBJPROP_TIME,1,T[0]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,1,BBL[0]);
      name="BM";  //--- iBands - BASE_LINE
      ObjectSetInteger(0,name,OBJPROP_TIME,T[1]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBM[1]);
      ObjectSetInteger(0,name,OBJPROP_TIME,1,T[0]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,1,BBM[0]);
      }
  }
//+------------------------------------------------------------------+

Étant donné que l'émission se poursuit dans le passé et dans le futur, les propriétés de la ligne de tendance devraient être les suivantes :

OBJPROP_RAY_LEFT = 1, (Ray va à gauche);
OBJPROP_RAY_RIGHT = 1, (Ray va à droite).

En conséquence, le graphique avec des lignes supplémentaires ressemblera à celui présenté à la Fig. 6.

La phase préparatoire est terminée, passons maintenant à l'émission. Nous allons créer la première série de points à l'intersection des lignes suivantes :

entre la ligne "MA" (iMA) et la ligne "BH" (iBands = UPPER_BAND);
entre la ligne "MA" (iMA) et la ligne "BL" (iBands = LOWER_BAND);
entre la ligne "MA" (iMA) et la ligne "BM" (iBands = BASE_BAND).

Fig. 6. Tracés auxiliaires. Continuation des lignes de l'indicateur à l'aide de lignes droites.

Fig. 6. Tracés auxiliaires. Poursuite des lignes de l'indicateur à l'aide de lignes droites.

Il est maintenant temps de calculer les coordonnées d'intersection et de tracer les points d'émission. Créons la fonction :

void Draw_Point(
                string   P_name,     // Object name (OBJ_ARROW)
                double   P_y1,       // Y-coordinate of the 1st line at the [1] bar
                double   P_y0,       // Y-coordinate of the 1st line at the [0] bar
                double   P_yy1,      // Y-coordinate of the 2nd line at the [1] bar 
                double   P_yy0,      // Y-coordinate of the 2nd line at the [0] bar
                char     P_code1,    // Char at the right side of the [0] bar
                char     P_code2,    // Char at the left side of the [0] bar
                color    P_color1,   // Color of point at the right side of the [0] bar
                color    P_color2    // color of point at the left side of the [0] bar
                )
  {
   double   P,X;
   datetime P_time;
   if(MathAbs((P_yy0-P_yy1)-(P_y0-P_y1))>0)
     {
      P=P_y1+(P_y0-P_y1)*(P_y1-P_yy1)/((P_yy0-P_yy1)-(P_y0-P_y1));
      X=(P_y1-P_yy1)/((P_yy0-P_yy1)-(P_y0-P_y1));
      if(X>draw_period)
        {
         P_time=T[0]+(int)(X*PeriodSeconds());
         ObjectCreate(0,P_name,OBJ_ARROW,0,0,0);
         ObjectSetDouble(0,P_name,OBJPROP_PRICE,P);
         ObjectSetInteger(0,P_name,OBJPROP_TIME,P_time);
         ObjectSetInteger(0,P_name,OBJPROP_WIDTH,0);
         ObjectSetInteger(0,P_name,OBJPROP_ARROWCODE,P_code1);
         ObjectSetInteger(0,P_name,OBJPROP_COLOR,P_color1);
         if(X<0)
           {
            ObjectSetInteger(0,P_name,OBJPROP_ARROWCODE,P_code2);
            ObjectSetInteger(0,P_name,OBJPROP_COLOR,P_color2);
           }
        }
     }
  }

Et en ajoutant les lignes de code suivantes à la fonction OnTick :

//+------------------------------------------------------------------+
   int GTC=GetTickCount();                                                    
//+------------------------------------------------------------------+
   name="H"+(string)GTC;
   Draw_Point(name,BBH[1],BBH[0],MA[1],MA[0],170,178,Red,Red);
   name="L"+(string)GTC;
   Draw_Point(name,BBL[1],BBL[0],MA[1],MA[0],170,178,Blue,Blue);
   name="M"+(string)GTC;
   Draw_Point(name,BBM[1],BBM[0],MA[1],MA[0],170,178,Green,Green);
//---
   ChartRedraw(0);

Exécutons maintenant l'Expert Advisor et examinons le résultat (Fig. 7.).

C'est bien, mais il y a d'autres cas d'intersection, que nous n'avons pas envisagés. Par exemple, l'indicateur iBands a trois lignes qui se croisent et peuvent compléter l'image globale.

Fig. 7. L'émission des indicateurs iMA et iBands (3 intersections).

Maintenant, essayons d'ajouter une autre série de points à l'émission calculée, l'intersection entre les lignes suivantes :

entre la ligne "BH" (iBands = UPPER_BAND) et la ligne "BL" (iBands = LOWER_BAND
entre la ligne "BH" (iBands = UPPER_BAND) et la ligne "BM" (iBands = BASE_BAND);
entre la ligne "BL" (iBands = LOWER_BAND) et la ligne "BM" (iBands = BASE_BAND).

En raison de ces intersections, nous obtiendrions 3 points, mais ils auront tous les mêmes coordonnées. Il suffit donc d'utiliser une seule intersection, entre la ligne "BH" et la ligne "BL".

Ajoutons ces lignes de code à notre Expert Advisor, et examinons le résultat (Fig. 8.).

   name="B"+(string)GTC;
   Draw_Point(name,BBH[1],BBH[0],BBL[1],BBL[0],170,178,Magenta,Magenta);

Fig. 8. Emission des indicateurs iMA et iBands (4 intersections).

Donc, nous avons l'émission, mais il y a un sentiment que nous avons raté quelque chose d'important. Néanmoins, qu'avons-nous manqué?

Pourquoi avons-nous utilisé uniquement de tels paramètres d'entrée ? Qu'obtiendrons-nous si nous les modifions? Et de toute façon, quel est leur rôle dans les émissions ?

D'accord, l'émission que nous avons correspond à une fréquence unique, résultant des paramètres d'entrée de l'indicateur. Pour calculer le spectre à multifréquence complet, il est nécessaire d'effectuer les mêmes calculs pour les autres fréquences. A titre d'exemple, voici ma version du spectre d'émission possible :

//---- handles for indicators
int         MAHandle[5];   // handles array of iMA indicators
int         BBHandle[7];   // handles array of iBands indicator
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   MAHandle[0]=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE);
   MAHandle[1]=iMA(NULL,0,34,0,MODE_EMA,PRICE_CLOSE);
   MAHandle[2]=iMA(NULL,0,55,0,MODE_EMA,PRICE_CLOSE);
   MAHandle[3]=iMA(NULL,0,89,0,MODE_EMA,PRICE_CLOSE);
   MAHandle[4]=iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE);
//---
   BBHandle[0]=iBands(NULL,0,55,0,2,PRICE_CLOSE);
   BBHandle[1]=iBands(NULL,0,89,0,2,PRICE_CLOSE);
   BBHandle[2]=iBands(NULL,0,144,0,2,PRICE_CLOSE);
   BBHandle[3]=iBands(NULL,0,233,0,2,PRICE_CLOSE);
   BBHandle[4]=iBands(NULL,0,377,0,2,PRICE_CLOSE);
   BBHandle[5]=iBands(NULL,0,610,0,2,PRICE_CLOSE);
   BBHandle[6]=iBands(NULL,0,987,0,2,PRICE_CLOSE);
//---
   return(0);
  }

Pour tenir compte de toutes les combinaisons possibles, ajoutons le code suivant à l'Expert Advisor :

//+------------------------------------------------------------------+
   CopyTime(NULL,0,0,10,T);
   ArraySetAsSeries(T,true);
   int GTC=GetTickCount();
//+------------------------------------------------------------------+
   int iMax=ArraySize(BBHandle)-1;
   int jMax=ArraySize(MAHandle)-1;
   for(int i=0; i<iMax; i++)
     {
      for(int j=0; j<jMax; j++)
        {
         //--- filling the arrays with current values
         CopyBuffer(MAHandle[j],0,0,2,MA);
         ArraySetAsSeries(MA,true);
         CopyBuffer(BBHandle[i],0,0,2,BBM);
         ArraySetAsSeries(BBM,true);
         CopyBuffer(BBHandle[i],1,0,2,BBH);
         ArraySetAsSeries(BBH,true);
         CopyBuffer(BBHandle[i],2,0,2,BBL);
         ArraySetAsSeries(BBL,true);

         name="H"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBH[1],BBH[0],MA[1],MA[0],250,158,Aqua,Aqua);
         name="L"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBL[1],BBL[0],MA[1],MA[0],250,158,Blue,Blue);
         name="M"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBM[1],BBM[0],MA[1],MA[0],250,158,Green,Green);
         name="B"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBH[1],BBH[0],BBL[1],BBL[0],250,158,Magenta,Magenta);
        }
     }
//---
   ChartRedraw(0);

Plus il y a de fréquences impliquées dans le spectre d'émission, meilleure sera l'image sur la graphique, mais vous ne devriez pas en abuser - c'est le moyen le plus simple d'épuiser les ressources informatiques et d'obtenir le chaos sur le graphique Le nombre de fréquences peut être déterminé expérimentalement. Pour une meilleure perception des graphismes, il faut porter une attention particulière au style de dessin.

Fig. 9. Spectre d'émission multifréquence.

Fig. 9. Spectre d'émission à multifréquence.

d’émission de styles de dessin

Le langage MQL5 fournit une large gamme de caractères Web Colors et Windings pour les émissions de dessin. Je voudrais partager mes réflexions à ce sujet :

Chaque personne a sa propre perception des images graphiques, il vous faudra donc un peu de temps pour personnaliser les émissions.
Le "chaos" de la Fig.9. ne permet pas de reconnaître des régularités ou des motifs dans les images. C'est un exemple de mauvais dessin.
Essayez d'utiliser les couleurs voisines dans le spectre de l'arc-en-ciel.
Les codes de caractères pour le passé (à partir du côté gauche de la barre [0]) et pour le futur (à partir du côté droit de la barre [0]) doivent différer.
La combinaison réussie de couleurs et de formes de points est en mesure de transformer l'émission en chefs-d'œuvre, ce qui contribuera non seulement à trader, mais ravira aussi vos yeux.

A titre d'exemple, voici ma version du style de dessin pour l'émission (voir Figures 10-17) :

         name="H"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBH[1],BBH[0],MA[1],MA[0],250,158,Aqua,Aqua);
         name="L"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBL[1],BBL[0],MA[1],MA[0],250,158,Blue,Blue);
         name="M"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBM[1],BBM[0],MA[1],MA[0],250,158,Magenta,Magenta);
         name="B"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBH[1],BBH[0],BBL[1],BBL[0],250,158,DarkOrchid,DarkOrchid);

La galerie d'émissions iMA et iBands

Les images avec ces émissions sont présentées dans ce chapitre.

Fig 10.

Fig 11.

Fig 11

Fig 12.

Fig 13.

Fig 14.

Fig 15.

Fig 16.

17.

Fig 17.

Analyse des émissions

L'analyse des émissions est une tâche distincte. Le plus utile est de regarder sa dynamique en temps réel, c'est le meilleur moyen de comprendre de nombreux effets et motifs.

Faites attention aux corrections de prix - il semble que l'émission "knows" le prix cible. De plus, vous pouvez voir les niveaux de prix de support, de résistance et d'équilibre.

Conclusion

Les émissions des indicateurs pourraient être intéressantes pour les traders et les développeurs de systèmes de trade, qui recherchent de nouvelles approches en matière d'étude et d'analyse de marché.
En tant qu'article préliminaire, il ne comporte pas des solutions toutes prêtes. Cependant, la technologie présentée pour le calcul des émissions peut être appliquée à d'autres indicateurs ou à leurs combinaisons.
En préparant cet article, j'ai recueilli plus de questions que de réponses. En voici quelques-uns : comment optimiser l'algorithme de dessin d'émission ; quel est le rôle des caractéristiques du spectre d'émission dans la structure d'émission ; comment utiliser les émissions dans le trading automatisé ?

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

Fichiers joints |

Télécharger ZIP

emission_bands_and_ma_en.mq5 (8.62 KB)

emission_bands_and_ma_spectrum_en.mq5 (5.63 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

Comment exporter des cotations de МetaTrader 5 vers des applications .NET à l'aide des services WCF

Vous souhaitez organiser l'exportation des cotations de MetaTrader 5 vers votre propre application ? La jonction MQL5-DLL permet de créer de telles solutions ! Cet article vous indiquera l'un des moyens d'exporter des cotations de MetaTrader 5 vers des applications écrites en .NET. Pour moi, il était plus intéressant, rationnel et facile d'implémenter l'export de cotations en utilisant cette même plateforme. Malheureusement, la version 5 ne prend toujours pas en charge .NET, donc comme autrefois, nous utiliserons la dll win32 avec la prise en charge de .NET comme couche intermédiaire.

Échange de Données entre les Indicateurs : C'est facile

Nous souhaitons créer un tel environnement, qui donnerait accès aux données d'indicateurs attachés à un graphique, et aurait les propriétés suivantes : absence de copie de données ; modification minimale du code des méthodes disponibles, si nous devons les utiliser ; Le code MQL est préférable (bien sûr, nous devons utiliser des DLL, mais nous n'utiliserons qu'une douzaine de chaînes de code C++). L'article décrit une méthode simple pour élaborer un environnement de programme pour le terminal MetaTrader, qui fournirait des moyens d'accès aux tampons d'indicateurs d'autres programmes MQL.

Implémentation pratique des Filtres Numériques dans MQL5 pour les débutants

L'idée du filtrage des signaux numériques a été largement discutée sur des sujets de forum concernant la création de systèmes de trading. Et il serait imprudent de ne pas créer un code standard de filtres numériques en MQL5. Dans cet article, l'auteur décrit la transformation du code d'un simple indicateur SMA de son article "Indicateurs Personnalisés dans MQL5 pour les Débutants" en code de filtre numérique plus compliqué et universel. Cet article est une suite logique de l'article précédent. Il explique également comment remplacer le texte dans le code et comment corriger les erreurs de programmation.

Comment Échanger des Données : Une DLL pour MQL5 en 10 minutes

Maintenant, peu de développeurs se rappellent de la façon d'écrire une DLL simple et des caractéristiques spéciales des différentes liaisons système. À l'aide de plusieurs exemples, je vais tenter de montrer l'ensemble du processus de création de la DLL simple en 10 minutes, ainsi que de discuter de certains détails techniques de notre implémentation de liaison. Je vais montrer étape par étape le processus de la création de DLL dans Visual Studio avec des exemples d'échange de différents types de variables (nombres, tableaux, chaînes, etc.). En outre, je vais vous expliquer comment protéger votre terminal client des plantages dans les DLL personnalisées.